git.delta.rocks / unique-network / refs/commits / 08e7d2834a5c

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//! # Refungible Pallet EVM API for tokens18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.2122extern crate alloc;2324use core::{25	char::{REPLACEMENT_CHARACTER, decode_utf16},26	convert::TryInto,27};28use evm_coder::{29	abi::AbiType, ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*,30	types::Property as PropertyStruct, weight,31};32use frame_support::{BoundedBTreeMap, BoundedVec};33use pallet_common::{34	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,35	erc::{CommonEvmHandler, CollectionCall, static_property::key},36	eth::{EthCrossAccount, EthTokenPermissions},37	Error as CommonError,38};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};40use pallet_evm_coder_substrate::{call, dispatch_to_evm};41use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};42use sp_core::{H160, Get};43use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};44use up_data_structs::{45	CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,46	PropertyKeyPermission, PropertyPermission, TokenId,47};4849use crate::{50	AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,51	TokenProperties, TokensMinted, TotalSupply, weights::WeightInfo,52};5354pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);5556/// @title A contract that allows to set and delete token properties and change token property permissions.57#[solidity_interface(name = TokenProperties)]58impl<T: Config> RefungibleHandle<T> {59	/// @notice Set permissions for token property.60	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.61	/// @param key Property key.62	/// @param isMutable Permission to mutate property.63	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.64	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.65	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]66	#[solidity(hide)]67	fn set_token_property_permission(68		&mut self,69		caller: caller,70		key: string,71		is_mutable: bool,72		collection_admin: bool,73		token_owner: bool,74	) -> Result<()> {75		let caller = T::CrossAccountId::from_eth(caller);76		<Pallet<T>>::set_token_property_permissions(77			self,78			&caller,79			vec![PropertyKeyPermission {80				key: <Vec<u8>>::from(key)81					.try_into()82					.map_err(|_| "too long key")?,83				permission: PropertyPermission {84					mutable: is_mutable,85					collection_admin,86					token_owner,87				},88			}],89		)90		.map_err(dispatch_to_evm::<T>)91	}9293	/// @notice Set permissions for token property.94	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.95	/// @param permissions Permissions for keys.96	fn set_token_property_permissions(97		&mut self,98		caller: caller,99		permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,100	) -> Result<()> {101		let caller = T::CrossAccountId::from_eth(caller);102		const PERMISSIONS_FIELDS_COUNT: usize = 3;103104		let mut perms = <Vec<_>>::new();105106		for (key, pp) in permissions {107			if pp.len() > PERMISSIONS_FIELDS_COUNT {108				return Err(alloc::format!(109					"Actual number of fields {} for {}, which exceeds the maximum value of {}",110					pp.len(),111					stringify!(EthTokenPermissions),112					PERMISSIONS_FIELDS_COUNT113				)114				.as_str()115				.into());116			}117118			let mut token_permission = PropertyPermission {119				mutable: false,120				collection_admin: false,121				token_owner: false,122			};123124			for (perm, value) in pp {125				match perm {126					EthTokenPermissions::Mutable => token_permission.mutable = value,127					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,128					EthTokenPermissions::CollectionAdmin => {129						token_permission.collection_admin = value130					}131				}132			}133134			perms.push(PropertyKeyPermission {135				key: <Vec<u8>>::from(key)136					.try_into()137					.map_err(|_| "too long key")?,138				permission: token_permission,139			});140		}141142		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)143			.map_err(dispatch_to_evm::<T>)144	}145146	fn token_property_permissions(147		&self,148	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {149		let mut res = <Vec<_>>::new();150		for (key, pp) in <Pallet<T>>::token_property_permission(self.id) {151			let key = string::from_utf8(key.into_inner()).unwrap();152			let pp = [153				(EthTokenPermissions::Mutable, pp.mutable),154				(EthTokenPermissions::TokenOwner, pp.token_owner),155				(EthTokenPermissions::CollectionAdmin, pp.collection_admin),156			]157			.into();158			res.push((key, pp));159		}160		Ok(res)161	}162163	/// @notice Set token property value.164	/// @dev Throws error if `msg.sender` has no permission to edit the property.165	/// @param tokenId ID of the token.166	/// @param key Property key.167	/// @param value Property value.168	#[solidity(hide)]169	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]170	fn set_property(171		&mut self,172		caller: caller,173		token_id: uint256,174		key: string,175		value: bytes,176	) -> Result<()> {177		let caller = T::CrossAccountId::from_eth(caller);178		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;179		let key = <Vec<u8>>::from(key)180			.try_into()181			.map_err(|_| "key too long")?;182		let value = value.0.try_into().map_err(|_| "value too long")?;183184		let nesting_budget = self185			.recorder186			.weight_calls_budget(<StructureWeight<T>>::find_parent());187188		<Pallet<T>>::set_token_property(189			self,190			&caller,191			TokenId(token_id),192			Property { key, value },193			&nesting_budget,194		)195		.map_err(dispatch_to_evm::<T>)196	}197198	/// @notice Set token properties value.199	/// @dev Throws error if `msg.sender` has no permission to edit the property.200	/// @param tokenId ID of the token.201	/// @param properties settable properties202	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]203	fn set_properties(204		&mut self,205		caller: caller,206		token_id: uint256,207		properties: Vec<PropertyStruct>,208	) -> Result<()> {209		let caller = T::CrossAccountId::from_eth(caller);210		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;211212		let nesting_budget = self213			.recorder214			.weight_calls_budget(<StructureWeight<T>>::find_parent());215216		let properties = properties217			.into_iter()218			.map(|PropertyStruct { key, value }| {219				let key = <Vec<u8>>::from(key)220					.try_into()221					.map_err(|_| "key too large")?;222223				let value = value.0.try_into().map_err(|_| "value too large")?;224225				Ok(Property { key, value })226			})227			.collect::<Result<Vec<_>>>()?;228229		<Pallet<T>>::set_token_properties(230			self,231			&caller,232			TokenId(token_id),233			properties.into_iter(),234			false,235			&nesting_budget,236		)237		.map_err(dispatch_to_evm::<T>)238	}239240	/// @notice Delete token property value.241	/// @dev Throws error if `msg.sender` has no permission to edit the property.242	/// @param tokenId ID of the token.243	/// @param key Property key.244	#[solidity(hide)]245	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]246	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {247		let caller = T::CrossAccountId::from_eth(caller);248		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;249		let key = <Vec<u8>>::from(key)250			.try_into()251			.map_err(|_| "key too long")?;252253		let nesting_budget = self254			.recorder255			.weight_calls_budget(<StructureWeight<T>>::find_parent());256257		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)258			.map_err(dispatch_to_evm::<T>)259	}260261	/// @notice Delete token properties value.262	/// @dev Throws error if `msg.sender` has no permission to edit the property.263	/// @param tokenId ID of the token.264	/// @param keys Properties key.265	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]266	fn delete_properties(267		&mut self,268		token_id: uint256,269		caller: caller,270		keys: Vec<string>,271	) -> Result<()> {272		let caller = T::CrossAccountId::from_eth(caller);273		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;274		let keys = keys275			.into_iter()276			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))277			.collect::<Result<Vec<_>>>()?;278279		let nesting_budget = self280			.recorder281			.weight_calls_budget(<StructureWeight<T>>::find_parent());282283		<Pallet<T>>::delete_token_properties(284			self,285			&caller,286			TokenId(token_id),287			keys.into_iter(),288			&nesting_budget,289		)290		.map_err(dispatch_to_evm::<T>)291	}292293	/// @notice Get token property value.294	/// @dev Throws error if key not found295	/// @param tokenId ID of the token.296	/// @param key Property key.297	/// @return Property value bytes298	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {299		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;300		let key = <Vec<u8>>::from(key)301			.try_into()302			.map_err(|_| "key too long")?;303304		let props = <TokenProperties<T>>::get((self.id, token_id));305		let prop = props.get(&key).ok_or("key not found")?;306307		Ok(prop.to_vec().into())308	}309}310311#[derive(ToLog)]312pub enum ERC721Events {313	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed314	///  (`to` == 0). Exception: during contract creation, any number of RFTs315	///  may be created and assigned without emitting Transfer.316	Transfer {317		#[indexed]318		from: address,319		#[indexed]320		to: address,321		#[indexed]322		token_id: uint256,323	},324	/// @dev Not supported325	Approval {326		#[indexed]327		owner: address,328		#[indexed]329		approved: address,330		#[indexed]331		token_id: uint256,332	},333	/// @dev Not supported334	#[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	/// @dev Not supported347	#[allow(dead_code)]348	MintingFinished {},349}350351#[solidity_interface(name = ERC721Metadata)]352impl<T: Config> RefungibleHandle<T>353where354	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,355{356	/// @notice A descriptive name for a collection of NFTs in this contract357	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`358	#[solidity(hide, rename_selector = "name")]359	fn name_proxy(&self) -> Result<string> {360		self.name()361	}362363	/// @notice An abbreviated name for NFTs in this contract364	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`365	#[solidity(hide, rename_selector = "symbol")]366	fn symbol_proxy(&self) -> Result<string> {367		self.symbol()368	}369370	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.371	///372	/// @dev If the token has a `url` property and it is not empty, it is returned.373	///  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`.374	///  If the collection property `baseURI` is empty or absent, return "" (empty string)375	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix376	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).377	///378	/// @return token's const_metadata379	#[solidity(rename_selector = "tokenURI")]380	fn token_uri(&self, token_id: uint256) -> Result<string> {381		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;382383		match get_token_property(self, token_id_u32, &key::url()).as_deref() {384			Err(_) | Ok("") => (),385			Ok(url) => {386				return Ok(url.into());387			}388		};389390		let base_uri =391			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())392				.map(BoundedVec::into_inner)393				.map(string::from_utf8)394				.transpose()395				.map_err(|e| {396					Error::Revert(alloc::format!(397						"Can not convert value \"baseURI\" to string with error \"{}\"",398						e399					))400				})?;401402		let base_uri = match base_uri.as_deref() {403			None | Some("") => {404				return Ok("".into());405			}406			Some(base_uri) => base_uri.into(),407		};408409		Ok(410			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {411				Err(_) | Ok("") => base_uri,412				Ok(suffix) => base_uri + suffix,413			},414		)415	}416}417418/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension419/// @dev See https://eips.ethereum.org/EIPS/eip-721420#[solidity_interface(name = ERC721Enumerable)]421impl<T: Config> RefungibleHandle<T> {422	/// @notice Enumerate valid RFTs423	/// @param index A counter less than `totalSupply()`424	/// @return The token identifier for the `index`th NFT,425	///  (sort order not specified)426	fn token_by_index(&self, index: uint256) -> Result<uint256> {427		Ok(index)428	}429430	/// Not implemented431	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {432		// TODO: Not implemetable433		Err("not implemented".into())434	}435436	/// @notice Count RFTs tracked by this contract437	/// @return A count of valid RFTs tracked by this contract, where each one of438	///  them has an assigned and queryable owner not equal to the zero address439	fn total_supply(&self) -> Result<uint256> {440		self.consume_store_reads(1)?;441		Ok(<Pallet<T>>::total_supply(self).into())442	}443}444445/// @title ERC-721 Non-Fungible Token Standard446/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md447#[solidity_interface(name = ERC721, events(ERC721Events))]448impl<T: Config> RefungibleHandle<T> {449	/// @notice Count all RFTs assigned to an owner450	/// @dev RFTs assigned to the zero address are considered invalid, and this451	///  function throws for queries about the zero address.452	/// @param owner An address for whom to query the balance453	/// @return The number of RFTs owned by `owner`, possibly zero454	fn balance_of(&self, owner: address) -> Result<uint256> {455		self.consume_store_reads(1)?;456		let owner = T::CrossAccountId::from_eth(owner);457		let balance = <AccountBalance<T>>::get((self.id, owner));458		Ok(balance.into())459	}460461	/// @notice Find the owner of an RFT462	/// @dev RFTs assigned to zero address are considered invalid, and queries463	///  about them do throw.464	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for465	///  the tokens that are partially owned.466	/// @param tokenId The identifier for an RFT467	/// @return The address of the owner of the RFT468	fn owner_of(&self, token_id: uint256) -> Result<address> {469		self.consume_store_reads(2)?;470		let token = token_id.try_into()?;471		let owner = <Pallet<T>>::token_owner(self.id, token);472		Ok(owner473			.map(|address| *address.as_eth())474			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))475	}476477	/// @dev Not implemented478	fn safe_transfer_from_with_data(479		&mut self,480		_from: address,481		_to: address,482		_token_id: uint256,483		_data: bytes,484	) -> Result<void> {485		// TODO: Not implemetable486		Err("not implemented".into())487	}488489	/// @dev Not implemented490	fn safe_transfer_from(491		&mut self,492		_from: address,493		_to: address,494		_token_id: uint256,495	) -> Result<void> {496		// TODO: Not implemetable497		Err("not implemented".into())498	}499500	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE501	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE502	///  THEY MAY BE PERMANENTLY LOST503	/// @dev Throws unless `msg.sender` is the current owner or an authorized504	///  operator for this RFT. Throws if `from` is not the current owner. Throws505	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.506	///  Throws if RFT pieces have multiple owners.507	/// @param from The current owner of the NFT508	/// @param to The new owner509	/// @param tokenId The NFT to transfer510	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]511	fn transfer_from(512		&mut self,513		caller: caller,514		from: address,515		to: address,516		token_id: uint256,517	) -> Result<void> {518		let caller = T::CrossAccountId::from_eth(caller);519		let from = T::CrossAccountId::from_eth(from);520		let to = T::CrossAccountId::from_eth(to);521		let token = token_id.try_into()?;522		let budget = self523			.recorder524			.weight_calls_budget(<StructureWeight<T>>::find_parent());525526		let balance = balance(&self, token, &from)?;527		ensure_single_owner(&self, token, balance)?;528529		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)530			.map_err(dispatch_to_evm::<T>)?;531532		Ok(())533	}534535	/// @dev Not implemented536	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {537		Err("not implemented".into())538	}539540	/// @notice Sets or unsets the approval of a given operator.541	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.542	/// @param operator Operator543	/// @param approved Should operator status be granted or revoked?544	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]545	fn set_approval_for_all(546		&mut self,547		caller: caller,548		operator: address,549		approved: bool,550	) -> Result<void> {551		let caller = T::CrossAccountId::from_eth(caller);552		let operator = T::CrossAccountId::from_eth(operator);553554		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)555			.map_err(dispatch_to_evm::<T>)?;556		Ok(())557	}558559	/// @dev Not implemented560	fn get_approved(&self, _token_id: uint256) -> Result<address> {561		// TODO: Not implemetable562		Err("not implemented".into())563	}564565	/// @notice Tells whether the given `owner` approves the `operator`.566	#[weight(<SelfWeightOf<T>>::allowance_for_all())]567	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {568		let owner = T::CrossAccountId::from_eth(owner);569		let operator = T::CrossAccountId::from_eth(operator);570571		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))572	}573574	/// @notice Returns collection helper contract address575	fn collection_helper_address(&self) -> Result<address> {576		Ok(T::ContractAddress::get())577	}578}579580/// Returns amount of pieces of `token` that `owner` have581pub fn balance<T: Config>(582	collection: &RefungibleHandle<T>,583	token: TokenId,584	owner: &T::CrossAccountId,585) -> Result<u128> {586	collection.consume_store_reads(1)?;587	let balance = <Balance<T>>::get((collection.id, token, &owner));588	Ok(balance)589}590591/// Throws if `owner_balance` is lower than total amount of `token` pieces592pub fn ensure_single_owner<T: Config>(593	collection: &RefungibleHandle<T>,594	token: TokenId,595	owner_balance: u128,596) -> Result<()> {597	collection.consume_store_reads(1)?;598	let total_supply = <TotalSupply<T>>::get((collection.id, token));599600	if owner_balance == 0 {601		return Err(dispatch_to_evm::<T>(602			<CommonError<T>>::MustBeTokenOwner.into(),603		));604	}605606	if total_supply != owner_balance {607		return Err("token has multiple owners".into());608	}609	Ok(())610}611612/// @title ERC721 Token that can be irreversibly burned (destroyed).613#[solidity_interface(name = ERC721Burnable)]614impl<T: Config> RefungibleHandle<T> {615	/// @notice Burns a specific ERC721 token.616	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized617	///  operator of the current owner.618	/// @param tokenId The RFT to approve619	#[weight(<SelfWeightOf<T>>::burn_item_fully())]620	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {621		let caller = T::CrossAccountId::from_eth(caller);622		let token = token_id.try_into()?;623624		let balance = balance(&self, token, &caller)?;625		ensure_single_owner(&self, token, balance)?;626627		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;628		Ok(())629	}630}631632/// @title ERC721 minting logic.633#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]634impl<T: Config> RefungibleHandle<T> {635	fn minting_finished(&self) -> Result<bool> {636		Ok(false)637	}638639	/// @notice Function to mint token.640	/// @param to The new owner641	/// @return uint256 The id of the newly minted token642	#[weight(<SelfWeightOf<T>>::create_item())]643	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {644		let token_id: uint256 = <TokensMinted<T>>::get(self.id)645			.checked_add(1)646			.ok_or("item id overflow")?647			.into();648		self.mint_check_id(caller, to, token_id)?;649		Ok(token_id)650	}651652	/// @notice Function to mint token.653	/// @dev `tokenId` should be obtained with `nextTokenId` method,654	///  unlike standard, you can't specify it manually655	/// @param to The new owner656	/// @param tokenId ID of the minted RFT657	#[solidity(hide, rename_selector = "mint")]658	#[weight(<SelfWeightOf<T>>::create_item())]659	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {660		let caller = T::CrossAccountId::from_eth(caller);661		let to = T::CrossAccountId::from_eth(to);662		let token_id: u32 = token_id.try_into()?;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 users = [(to.clone(), 1)]676			.into_iter()677			.collect::<BTreeMap<_, _>>()678			.try_into()679			.unwrap();680		<Pallet<T>>::create_item(681			self,682			&caller,683			CreateItemData::<T::CrossAccountId> {684				users,685				properties: CollectionPropertiesVec::default(),686			},687			&budget,688		)689		.map_err(dispatch_to_evm::<T>)?;690691		Ok(true)692	}693694	/// @notice Function to mint token with the given tokenUri.695	/// @param to The new owner696	/// @param tokenUri Token URI that would be stored in the NFT properties697	/// @return uint256 The id of the newly minted token698	#[solidity(rename_selector = "mintWithTokenURI")]699	#[weight(<SelfWeightOf<T>>::create_item())]700	fn mint_with_token_uri(701		&mut self,702		caller: caller,703		to: address,704		token_uri: string,705	) -> Result<uint256> {706		let token_id: uint256 = <TokensMinted<T>>::get(self.id)707			.checked_add(1)708			.ok_or("item id overflow")?709			.into();710		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;711		Ok(token_id)712	}713714	/// @notice Function to mint token with the given tokenUri.715	/// @dev `tokenId` should be obtained with `nextTokenId` method,716	///  unlike standard, you can't specify it manually717	/// @param to The new owner718	/// @param tokenId ID of the minted RFT719	/// @param tokenUri Token URI that would be stored in the RFT properties720	#[solidity(hide, rename_selector = "mintWithTokenURI")]721	#[weight(<SelfWeightOf<T>>::create_item())]722	fn mint_with_token_uri_check_id(723		&mut self,724		caller: caller,725		to: address,726		token_id: uint256,727		token_uri: string,728	) -> Result<bool> {729		let key = key::url();730		let permission = get_token_permission::<T>(self.id, &key)?;731		if !permission.collection_admin {732			return Err("Operation is not allowed".into());733		}734735		let caller = T::CrossAccountId::from_eth(caller);736		let to = T::CrossAccountId::from_eth(to);737		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;738		let budget = self739			.recorder740			.weight_calls_budget(<StructureWeight<T>>::find_parent());741742		if <TokensMinted<T>>::get(self.id)743			.checked_add(1)744			.ok_or("item id overflow")?745			!= token_id746		{747			return Err("item id should be next".into());748		}749750		let mut properties = CollectionPropertiesVec::default();751		properties752			.try_push(Property {753				key,754				value: token_uri755					.into_bytes()756					.try_into()757					.map_err(|_| "token uri is too long")?,758			})759			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;760761		let users = [(to.clone(), 1)]762			.into_iter()763			.collect::<BTreeMap<_, _>>()764			.try_into()765			.unwrap();766		<Pallet<T>>::create_item(767			self,768			&caller,769			CreateItemData::<T::CrossAccountId> { users, properties },770			&budget,771		)772		.map_err(dispatch_to_evm::<T>)?;773		Ok(true)774	}775776	/// @dev Not implemented777	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {778		Err("not implementable".into())779	}780}781782fn get_token_property<T: Config>(783	collection: &CollectionHandle<T>,784	token_id: u32,785	key: &up_data_structs::PropertyKey,786) -> Result<string> {787	collection.consume_store_reads(1)?;788	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))789		.map_err(|_| Error::Revert("Token properties not found".into()))?;790	if let Some(property) = properties.get(key) {791		return Ok(string::from_utf8_lossy(property).into());792	}793794	Err("Property tokenURI not found".into())795}796797fn get_token_permission<T: Config>(798	collection_id: CollectionId,799	key: &PropertyKey,800) -> Result<PropertyPermission> {801	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)802		.map_err(|_| Error::Revert("No permissions for collection".into()))?;803	let a = token_property_permissions804		.get(key)805		.map(Clone::clone)806		.ok_or_else(|| {807			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();808			Error::Revert(alloc::format!("No permission for key {}", key))809		})?;810	Ok(a)811}812813/// @title Unique extensions for ERC721.814#[solidity_interface(name = ERC721UniqueExtensions)]815impl<T: Config> RefungibleHandle<T>816where817	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,818{819	/// @notice A descriptive name for a collection of NFTs in this contract820	fn name(&self) -> Result<string> {821		Ok(decode_utf16(self.name.iter().copied())822			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))823			.collect::<string>())824	}825826	/// @notice An abbreviated name for NFTs in this contract827	fn symbol(&self) -> Result<string> {828		Ok(string::from_utf8_lossy(&self.token_prefix).into())829	}830831	/// @notice A description for the collection.832	fn description(&self) -> Result<string> {833		Ok(decode_utf16(self.description.iter().copied())834			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))835			.collect::<string>())836	}837838	/// Returns the owner (in cross format) of the token.839	///840	/// @param tokenId Id for the token.841	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {842		Self::token_owner(&self, token_id.try_into()?)843			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))844			.ok_or(Error::Revert("key too large".into()))845	}846847	/// Returns the token properties.848	///849	/// @param tokenId Id for the token.850	/// @param keys Properties keys. Empty keys for all propertyes.851	/// @return Vector of properties key/value pairs.852	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {853		let keys = keys854			.into_iter()855			.map(|key| {856				<Vec<u8>>::from(key)857					.try_into()858					.map_err(|_| Error::Revert("key too large".into()))859			})860			.collect::<Result<Vec<_>>>()?;861862		<Self as CommonCollectionOperations<T>>::token_properties(863			&self,864			token_id.try_into()?,865			if keys.is_empty() { None } else { Some(keys) },866		)867		.into_iter()868		.map(|p| {869			let key = string::from_utf8(p.key.to_vec())870				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;871			let value = bytes(p.value.to_vec());872			Ok(PropertyStruct { key, value })873		})874		.collect::<Result<Vec<_>>>()875	}876	/// @notice Transfer ownership of an RFT877	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`878	///  is the zero address. Throws if `tokenId` is not a valid RFT.879	///  Throws if RFT pieces have multiple owners.880	/// @param to The new owner881	/// @param tokenId The RFT to transfer882	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]883	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {884		let caller = T::CrossAccountId::from_eth(caller);885		let to = T::CrossAccountId::from_eth(to);886		let token = token_id.try_into()?;887		let budget = self888			.recorder889			.weight_calls_budget(<StructureWeight<T>>::find_parent());890891		let balance = balance(self, token, &caller)?;892		ensure_single_owner(self, token, balance)?;893894		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)895			.map_err(dispatch_to_evm::<T>)?;896		Ok(())897	}898899	/// @notice Transfer ownership of an RFT900	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`901	///  is the zero address. Throws if `tokenId` is not a valid RFT.902	///  Throws if RFT pieces have multiple owners.903	/// @param to The new owner904	/// @param tokenId The RFT to transfer905	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]906	fn transfer_cross(907		&mut self,908		caller: caller,909		to: EthCrossAccount,910		token_id: uint256,911	) -> Result<void> {912		let caller = T::CrossAccountId::from_eth(caller);913		let to = to.into_sub_cross_account::<T>()?;914		let token = token_id.try_into()?;915		let budget = self916			.recorder917			.weight_calls_budget(<StructureWeight<T>>::find_parent());918919		let balance = balance(self, token, &caller)?;920		ensure_single_owner(self, token, balance)?;921922		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)923			.map_err(dispatch_to_evm::<T>)?;924		Ok(())925	}926927	/// @notice Transfer ownership of an RFT928	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`929	///  is the zero address. Throws if `tokenId` is not a valid RFT.930	///  Throws if RFT pieces have multiple owners.931	/// @param to The new owner932	/// @param tokenId The RFT to transfer933	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]934	fn transfer_from_cross(935		&mut self,936		caller: caller,937		from: EthCrossAccount,938		to: EthCrossAccount,939		token_id: uint256,940	) -> Result<void> {941		let caller = T::CrossAccountId::from_eth(caller);942		let from = from.into_sub_cross_account::<T>()?;943		let to = to.into_sub_cross_account::<T>()?;944		let token_id = token_id.try_into()?;945		let budget = self946			.recorder947			.weight_calls_budget(<StructureWeight<T>>::find_parent());948949		let balance = balance(self, token_id, &from)?;950		ensure_single_owner(self, token_id, balance)?;951952		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)953			.map_err(dispatch_to_evm::<T>)?;954		Ok(())955	}956957	/// @notice Burns a specific ERC721 token.958	/// @dev Throws unless `msg.sender` is the current owner or an authorized959	///  operator for this RFT. Throws if `from` is not the current owner. Throws960	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.961	///  Throws if RFT pieces have multiple owners.962	/// @param from The current owner of the RFT963	/// @param tokenId The RFT to transfer964	#[solidity(hide)]965	#[weight(<SelfWeightOf<T>>::burn_from())]966	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {967		let caller = T::CrossAccountId::from_eth(caller);968		let from = T::CrossAccountId::from_eth(from);969		let token = token_id.try_into()?;970		let budget = self971			.recorder972			.weight_calls_budget(<StructureWeight<T>>::find_parent());973974		let balance = balance(self, token, &from)?;975		ensure_single_owner(self, token, balance)?;976977		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)978			.map_err(dispatch_to_evm::<T>)?;979		Ok(())980	}981982	/// @notice Burns a specific ERC721 token.983	/// @dev Throws unless `msg.sender` is the current owner or an authorized984	///  operator for this RFT. Throws if `from` is not the current owner. Throws985	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.986	///  Throws if RFT pieces have multiple owners.987	/// @param from The current owner of the RFT988	/// @param tokenId The RFT to transfer989	#[weight(<SelfWeightOf<T>>::burn_from())]990	fn burn_from_cross(991		&mut self,992		caller: caller,993		from: EthCrossAccount,994		token_id: uint256,995	) -> Result<void> {996		let caller = T::CrossAccountId::from_eth(caller);997		let from = from.into_sub_cross_account::<T>()?;998		let token = token_id.try_into()?;999		let budget = self1000			.recorder1001			.weight_calls_budget(<StructureWeight<T>>::find_parent());10021003		let balance = balance(self, token, &from)?;1004		ensure_single_owner(self, token, balance)?;10051006		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)1007			.map_err(dispatch_to_evm::<T>)?;1008		Ok(())1009	}10101011	/// @notice Returns next free RFT ID.1012	fn next_token_id(&self) -> Result<uint256> {1013		self.consume_store_reads(1)?;1014		Ok(<TokensMinted<T>>::get(self.id)1015			.checked_add(1)1016			.ok_or("item id overflow")?1017			.into())1018	}10191020	/// @notice Function to mint multiple tokens.1021	/// @dev `tokenIds` should be an array of consecutive numbers and first number1022	///  should be obtained with `nextTokenId` method1023	/// @param to The new owner1024	/// @param tokenIds IDs of the minted RFTs1025	#[solidity(hide)]1026	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]1027	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {1028		let caller = T::CrossAccountId::from_eth(caller);1029		let to = T::CrossAccountId::from_eth(to);1030		let mut expected_index = <TokensMinted<T>>::get(self.id)1031			.checked_add(1)1032			.ok_or("item id overflow")?;1033		let budget = self1034			.recorder1035			.weight_calls_budget(<StructureWeight<T>>::find_parent());10361037		let total_tokens = token_ids.len();1038		for id in token_ids.into_iter() {1039			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1040			if id != expected_index {1041				return Err("item id should be next".into());1042			}1043			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1044		}1045		let users = [(to.clone(), 1)]1046			.into_iter()1047			.collect::<BTreeMap<_, _>>()1048			.try_into()1049			.unwrap();1050		let create_item_data = CreateItemData::<T::CrossAccountId> {1051			users,1052			properties: CollectionPropertiesVec::default(),1053		};1054		let data = (0..total_tokens)1055			.map(|_| create_item_data.clone())1056			.collect();10571058		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1059			.map_err(dispatch_to_evm::<T>)?;1060		Ok(true)1061	}10621063	/// @notice Function to mint multiple tokens with the given tokenUris.1064	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1065	///  numbers and first number should be obtained with `nextTokenId` method1066	/// @param to The new owner1067	/// @param tokens array of pairs of token ID and token URI for minted tokens1068	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1069	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1070	fn mint_bulk_with_token_uri(1071		&mut self,1072		caller: caller,1073		to: address,1074		tokens: Vec<(uint256, string)>,1075	) -> Result<bool> {1076		let key = key::url();1077		let caller = T::CrossAccountId::from_eth(caller);1078		let to = T::CrossAccountId::from_eth(to);1079		let mut expected_index = <TokensMinted<T>>::get(self.id)1080			.checked_add(1)1081			.ok_or("item id overflow")?;1082		let budget = self1083			.recorder1084			.weight_calls_budget(<StructureWeight<T>>::find_parent());10851086		let mut data = Vec::with_capacity(tokens.len());1087		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1088			.into_iter()1089			.collect::<BTreeMap<_, _>>()1090			.try_into()1091			.unwrap();1092		for (id, token_uri) in tokens {1093			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1094			if id != expected_index {1095				return Err("item id should be next".into());1096			}1097			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10981099			let mut properties = CollectionPropertiesVec::default();1100			properties1101				.try_push(Property {1102					key: key.clone(),1103					value: token_uri1104						.into_bytes()1105						.try_into()1106						.map_err(|_| "token uri is too long")?,1107				})1108				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;11091110			let create_item_data = CreateItemData::<T::CrossAccountId> {1111				users: users.clone(),1112				properties,1113			};1114			data.push(create_item_data);1115		}11161117		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1118			.map_err(dispatch_to_evm::<T>)?;1119		Ok(true)1120	}11211122	/// Returns EVM address for refungible token1123	///1124	/// @param token ID of the token1125	fn token_contract_address(&self, token: uint256) -> Result<address> {1126		Ok(T::EvmTokenAddressMapping::token_to_address(1127			self.id,1128			token.try_into().map_err(|_| "token id overflow")?,1129		))1130	}1131}11321133#[solidity_interface(1134	name = UniqueRefungible,1135	is(1136		ERC721,1137		ERC721Enumerable,1138		ERC721UniqueExtensions,1139		ERC721UniqueMintable,1140		ERC721Burnable,1141		ERC721Metadata(if(this.flags.erc721metadata)),1142		Collection(via(common_mut returns CollectionHandle<T>)),1143		TokenProperties,1144	)1145)]1146impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11471148// Not a tests, but code generators1149generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1150generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);11511152impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1153where1154	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1155{1156	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1157	fn call(1158		self,1159		handle: &mut impl PrecompileHandle,1160	) -> Option<pallet_common::erc::PrecompileResult> {1161		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1162	}1163}