git.delta.rocks / unique-network / refs/commits / 33d3cd09a241

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	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]97	fn set_token_property_permissions(98		&mut self,99		caller: caller,100		permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,101	) -> Result<()> {102		let caller = T::CrossAccountId::from_eth(caller);103		const PERMISSIONS_FIELDS_COUNT: usize = 3;104105		let mut perms = Vec::new();106107		for (key, pp) in permissions {108			if pp.len() > PERMISSIONS_FIELDS_COUNT {109				return Err(alloc::format!(110					"Actual number of fields {} for {}, which exceeds the maximum value of {}",111					pp.len(),112					stringify!(EthTokenPermissions),113					PERMISSIONS_FIELDS_COUNT114				)115				.as_str()116				.into());117			}118119			let mut token_permission = PropertyPermission {120				mutable: false,121				collection_admin: false,122				token_owner: false,123			};124125			for (perm, value) in pp {126				match perm {127					EthTokenPermissions::Mutable => token_permission.mutable = value,128					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,129					EthTokenPermissions::CollectionAdmin => {130						token_permission.collection_admin = value131					}132				}133			}134135			perms.push(PropertyKeyPermission {136				key: key.into_bytes().try_into().map_err(|_| "too long key")?,137				permission: token_permission,138			});139		}140141		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)142			.map_err(dispatch_to_evm::<T>)143	}144145	/// @notice Get permissions for token properties.146	fn token_property_permissions(147		&self,148	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {149		let perms = <Pallet<T>>::token_property_permission(self.id);150		Ok(perms151			.into_iter()152			.map(|(key, pp)| {153				let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid");154				let pp = vec![155					(EthTokenPermissions::Mutable, pp.mutable),156					(EthTokenPermissions::TokenOwner, pp.token_owner),157					(EthTokenPermissions::CollectionAdmin, pp.collection_admin),158				];159				(key, pp)160			})161			.collect())162	}163164	/// @notice Set token property value.165	/// @dev Throws error if `msg.sender` has no permission to edit the property.166	/// @param tokenId ID of the token.167	/// @param key Property key.168	/// @param value Property value.169	#[solidity(hide)]170	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]171	fn set_property(172		&mut self,173		caller: caller,174		token_id: uint256,175		key: string,176		value: bytes,177	) -> Result<()> {178		let caller = T::CrossAccountId::from_eth(caller);179		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;180		let key = <Vec<u8>>::from(key)181			.try_into()182			.map_err(|_| "key too long")?;183		let value = value.0.try_into().map_err(|_| "value too long")?;184185		let nesting_budget = self186			.recorder187			.weight_calls_budget(<StructureWeight<T>>::find_parent());188189		<Pallet<T>>::set_token_property(190			self,191			&caller,192			TokenId(token_id),193			Property { key, value },194			&nesting_budget,195		)196		.map_err(dispatch_to_evm::<T>)197	}198199	/// @notice Set token properties value.200	/// @dev Throws error if `msg.sender` has no permission to edit the property.201	/// @param tokenId ID of the token.202	/// @param properties settable properties203	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]204	fn set_properties(205		&mut self,206		caller: caller,207		token_id: uint256,208		properties: Vec<PropertyStruct>,209	) -> Result<()> {210		let caller = T::CrossAccountId::from_eth(caller);211		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;212213		let nesting_budget = self214			.recorder215			.weight_calls_budget(<StructureWeight<T>>::find_parent());216217		let properties = properties218			.into_iter()219			.map(|PropertyStruct { key, value }| {220				let key = <Vec<u8>>::from(key)221					.try_into()222					.map_err(|_| "key too large")?;223224				let value = value.0.try_into().map_err(|_| "value too large")?;225226				Ok(Property { key, value })227			})228			.collect::<Result<Vec<_>>>()?;229230		<Pallet<T>>::set_token_properties(231			self,232			&caller,233			TokenId(token_id),234			properties.into_iter(),235			false,236			&nesting_budget,237		)238		.map_err(dispatch_to_evm::<T>)239	}240241	/// @notice Delete token property value.242	/// @dev Throws error if `msg.sender` has no permission to edit the property.243	/// @param tokenId ID of the token.244	/// @param key Property key.245	#[solidity(hide)]246	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]247	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {248		let caller = T::CrossAccountId::from_eth(caller);249		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;250		let key = <Vec<u8>>::from(key)251			.try_into()252			.map_err(|_| "key too long")?;253254		let nesting_budget = self255			.recorder256			.weight_calls_budget(<StructureWeight<T>>::find_parent());257258		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)259			.map_err(dispatch_to_evm::<T>)260	}261262	/// @notice Delete token properties value.263	/// @dev Throws error if `msg.sender` has no permission to edit the property.264	/// @param tokenId ID of the token.265	/// @param keys Properties key.266	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]267	fn delete_properties(268		&mut self,269		token_id: uint256,270		caller: caller,271		keys: Vec<string>,272	) -> Result<()> {273		let caller = T::CrossAccountId::from_eth(caller);274		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;275		let keys = keys276			.into_iter()277			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))278			.collect::<Result<Vec<_>>>()?;279280		let nesting_budget = self281			.recorder282			.weight_calls_budget(<StructureWeight<T>>::find_parent());283284		<Pallet<T>>::delete_token_properties(285			self,286			&caller,287			TokenId(token_id),288			keys.into_iter(),289			&nesting_budget,290		)291		.map_err(dispatch_to_evm::<T>)292	}293294	/// @notice Get token property value.295	/// @dev Throws error if key not found296	/// @param tokenId ID of the token.297	/// @param key Property key.298	/// @return Property value bytes299	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {300		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;301		let key = <Vec<u8>>::from(key)302			.try_into()303			.map_err(|_| "key too long")?;304305		let props = <TokenProperties<T>>::get((self.id, token_id));306		let prop = props.get(&key).ok_or("key not found")?;307308		Ok(prop.to_vec().into())309	}310}311312#[derive(ToLog)]313pub enum ERC721Events {314	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed315	///  (`to` == 0). Exception: during contract creation, any number of RFTs316	///  may be created and assigned without emitting Transfer.317	Transfer {318		#[indexed]319		from: address,320		#[indexed]321		to: address,322		#[indexed]323		token_id: uint256,324	},325	/// @dev Not supported326	Approval {327		#[indexed]328		owner: address,329		#[indexed]330		approved: address,331		#[indexed]332		token_id: uint256,333	},334	/// @dev Not supported335	#[allow(dead_code)]336	ApprovalForAll {337		#[indexed]338		owner: address,339		#[indexed]340		operator: address,341		approved: bool,342	},343}344345#[derive(ToLog)]346pub enum ERC721UniqueMintableEvents {347	/// @dev Not supported348	#[allow(dead_code)]349	MintingFinished {},350}351352#[solidity_interface(name = ERC721Metadata)]353impl<T: Config> RefungibleHandle<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)]422impl<T: Config> RefungibleHandle<T> {423	/// @notice Enumerate valid RFTs424	/// @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	/// 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 RFTs tracked by this contract438	/// @return A count of valid RFTs 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))]449impl<T: Config> RefungibleHandle<T> {450	/// @notice Count all RFTs assigned to an owner451	/// @dev RFTs 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 RFTs 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	}461462	/// @notice Find the owner of an RFT463	/// @dev RFTs assigned to zero address are considered invalid, and queries464	///  about them do throw.465	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for466	///  the tokens that are partially owned.467	/// @param tokenId The identifier for an RFT468	/// @return The address of the owner of the RFT469	fn owner_of(&self, token_id: uint256) -> Result<address> {470		self.consume_store_reads(2)?;471		let token = token_id.try_into()?;472		let owner = <Pallet<T>>::token_owner(self.id, token);473		Ok(owner474			.map(|address| *address.as_eth())475			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))476	}477478	/// @dev Not implemented479	fn safe_transfer_from_with_data(480		&mut self,481		_from: address,482		_to: address,483		_token_id: uint256,484		_data: bytes,485	) -> Result<void> {486		// TODO: Not implemetable487		Err("not implemented".into())488	}489490	/// @dev Not implemented491	fn safe_transfer_from(492		&mut self,493		_from: address,494		_to: address,495		_token_id: uint256,496	) -> Result<void> {497		// TODO: Not implemetable498		Err("not implemented".into())499	}500501	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE502	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE503	///  THEY MAY BE PERMANENTLY LOST504	/// @dev Throws unless `msg.sender` is the current owner or an authorized505	///  operator for this RFT. Throws if `from` is not the current owner. Throws506	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.507	///  Throws if RFT pieces have multiple owners.508	/// @param from The current owner of the NFT509	/// @param to The new owner510	/// @param tokenId The NFT to transfer511	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]512	fn transfer_from(513		&mut self,514		caller: caller,515		from: address,516		to: address,517		token_id: uint256,518	) -> Result<void> {519		let caller = T::CrossAccountId::from_eth(caller);520		let from = T::CrossAccountId::from_eth(from);521		let to = T::CrossAccountId::from_eth(to);522		let token = token_id.try_into()?;523		let budget = self524			.recorder525			.weight_calls_budget(<StructureWeight<T>>::find_parent());526527		let balance = balance(&self, token, &from)?;528		ensure_single_owner(&self, token, balance)?;529530		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)531			.map_err(dispatch_to_evm::<T>)?;532533		Ok(())534	}535536	/// @dev Not implemented537	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {538		Err("not implemented".into())539	}540541	/// @notice Sets or unsets the approval of a given operator.542	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.543	/// @param operator Operator544	/// @param approved Should operator status be granted or revoked?545	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]546	fn set_approval_for_all(547		&mut self,548		caller: caller,549		operator: address,550		approved: bool,551	) -> Result<void> {552		let caller = T::CrossAccountId::from_eth(caller);553		let operator = T::CrossAccountId::from_eth(operator);554555		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)556			.map_err(dispatch_to_evm::<T>)?;557		Ok(())558	}559560	/// @dev Not implemented561	fn get_approved(&self, _token_id: uint256) -> Result<address> {562		// TODO: Not implemetable563		Err("not implemented".into())564	}565566	/// @notice Tells whether the given `owner` approves the `operator`.567	#[weight(<SelfWeightOf<T>>::allowance_for_all())]568	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {569		let owner = T::CrossAccountId::from_eth(owner);570		let operator = T::CrossAccountId::from_eth(operator);571572		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))573	}574575	/// @notice Returns collection helper contract address576	fn collection_helper_address(&self) -> Result<address> {577		Ok(T::ContractAddress::get())578	}579}580581/// Returns amount of pieces of `token` that `owner` have582pub fn balance<T: Config>(583	collection: &RefungibleHandle<T>,584	token: TokenId,585	owner: &T::CrossAccountId,586) -> Result<u128> {587	collection.consume_store_reads(1)?;588	let balance = <Balance<T>>::get((collection.id, token, &owner));589	Ok(balance)590}591592/// Throws if `owner_balance` is lower than total amount of `token` pieces593pub fn ensure_single_owner<T: Config>(594	collection: &RefungibleHandle<T>,595	token: TokenId,596	owner_balance: u128,597) -> Result<()> {598	collection.consume_store_reads(1)?;599	let total_supply = <TotalSupply<T>>::get((collection.id, token));600601	if owner_balance == 0 {602		return Err(dispatch_to_evm::<T>(603			<CommonError<T>>::MustBeTokenOwner.into(),604		));605	}606607	if total_supply != owner_balance {608		return Err("token has multiple owners".into());609	}610	Ok(())611}612613/// @title ERC721 Token that can be irreversibly burned (destroyed).614#[solidity_interface(name = ERC721Burnable)]615impl<T: Config> RefungibleHandle<T> {616	/// @notice Burns a specific ERC721 token.617	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized618	///  operator of the current owner.619	/// @param tokenId The RFT to approve620	#[weight(<SelfWeightOf<T>>::burn_item_fully())]621	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {622		let caller = T::CrossAccountId::from_eth(caller);623		let token = token_id.try_into()?;624625		let balance = balance(&self, token, &caller)?;626		ensure_single_owner(&self, token, balance)?;627628		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;629		Ok(())630	}631}632633/// @title ERC721 minting logic.634#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]635impl<T: Config> RefungibleHandle<T> {636	fn minting_finished(&self) -> Result<bool> {637		Ok(false)638	}639640	/// @notice Function to mint a token.641	/// @param to The new owner642	/// @return uint256 The id of the newly minted token643	#[weight(<SelfWeightOf<T>>::create_item())]644	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {645		let token_id: uint256 = <TokensMinted<T>>::get(self.id)646			.checked_add(1)647			.ok_or("item id overflow")?648			.into();649		self.mint_check_id(caller, to, token_id)?;650		Ok(token_id)651	}652653	/// @notice Function to mint a token.654	/// @dev `tokenId` should be obtained with `nextTokenId` method,655	///  unlike standard, you can't specify it manually656	/// @param to The new owner657	/// @param tokenId ID of the minted RFT658	#[solidity(hide, rename_selector = "mint")]659	#[weight(<SelfWeightOf<T>>::create_item())]660	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {661		let caller = T::CrossAccountId::from_eth(caller);662		let to = T::CrossAccountId::from_eth(to);663		let token_id: u32 = token_id.try_into()?;664		let budget = self665			.recorder666			.weight_calls_budget(<StructureWeight<T>>::find_parent());667668		if <TokensMinted<T>>::get(self.id)669			.checked_add(1)670			.ok_or("item id overflow")?671			!= token_id672		{673			return Err("item id should be next".into());674		}675676		let users = [(to.clone(), 1)]677			.into_iter()678			.collect::<BTreeMap<_, _>>()679			.try_into()680			.unwrap();681		<Pallet<T>>::create_item(682			self,683			&caller,684			CreateItemData::<T> {685				users,686				properties: CollectionPropertiesVec::default(),687			},688			&budget,689		)690		.map_err(dispatch_to_evm::<T>)?;691692		Ok(true)693	}694695	/// @notice Function to mint token with the given tokenUri.696	/// @param to The new owner697	/// @param tokenUri Token URI that would be stored in the NFT properties698	/// @return uint256 The id of the newly minted token699	#[solidity(rename_selector = "mintWithTokenURI")]700	#[weight(<SelfWeightOf<T>>::create_item())]701	fn mint_with_token_uri(702		&mut self,703		caller: caller,704		to: address,705		token_uri: string,706	) -> Result<uint256> {707		let token_id: uint256 = <TokensMinted<T>>::get(self.id)708			.checked_add(1)709			.ok_or("item id overflow")?710			.into();711		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;712		Ok(token_id)713	}714715	/// @notice Function to mint token with the given tokenUri.716	/// @dev `tokenId` should be obtained with `nextTokenId` method,717	///  unlike standard, you can't specify it manually718	/// @param to The new owner719	/// @param tokenId ID of the minted RFT720	/// @param tokenUri Token URI that would be stored in the RFT properties721	#[solidity(hide, rename_selector = "mintWithTokenURI")]722	#[weight(<SelfWeightOf<T>>::create_item())]723	fn mint_with_token_uri_check_id(724		&mut self,725		caller: caller,726		to: address,727		token_id: uint256,728		token_uri: string,729	) -> Result<bool> {730		let key = key::url();731		let permission = get_token_permission::<T>(self.id, &key)?;732		if !permission.collection_admin {733			return Err("Operation is not allowed".into());734		}735736		let caller = T::CrossAccountId::from_eth(caller);737		let to = T::CrossAccountId::from_eth(to);738		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;739		let budget = self740			.recorder741			.weight_calls_budget(<StructureWeight<T>>::find_parent());742743		if <TokensMinted<T>>::get(self.id)744			.checked_add(1)745			.ok_or("item id overflow")?746			!= token_id747		{748			return Err("item id should be next".into());749		}750751		let mut properties = CollectionPropertiesVec::default();752		properties753			.try_push(Property {754				key,755				value: token_uri756					.into_bytes()757					.try_into()758					.map_err(|_| "token uri is too long")?,759			})760			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;761762		let users = [(to.clone(), 1)]763			.into_iter()764			.collect::<BTreeMap<_, _>>()765			.try_into()766			.unwrap();767		<Pallet<T>>::create_item(768			self,769			&caller,770			CreateItemData::<T> { users, properties },771			&budget,772		)773		.map_err(dispatch_to_evm::<T>)?;774		Ok(true)775	}776777	/// @dev Not implemented778	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {779		Err("not implementable".into())780	}781}782783fn get_token_property<T: Config>(784	collection: &CollectionHandle<T>,785	token_id: u32,786	key: &up_data_structs::PropertyKey,787) -> Result<string> {788	collection.consume_store_reads(1)?;789	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))790		.map_err(|_| Error::Revert("Token properties not found".into()))?;791	if let Some(property) = properties.get(key) {792		return Ok(string::from_utf8_lossy(property).into());793	}794795	Err("Property tokenURI not found".into())796}797798fn get_token_permission<T: Config>(799	collection_id: CollectionId,800	key: &PropertyKey,801) -> Result<PropertyPermission> {802	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)803		.map_err(|_| Error::Revert("No permissions for collection".into()))?;804	let a = token_property_permissions805		.get(key)806		.map(Clone::clone)807		.ok_or_else(|| {808			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();809			Error::Revert(alloc::format!("No permission for key {}", key))810		})?;811	Ok(a)812}813814/// @title Unique extensions for ERC721.815#[solidity_interface(name = ERC721UniqueExtensions)]816impl<T: Config> RefungibleHandle<T>817where818	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,819{820	/// @notice A descriptive name for a collection of NFTs in this contract821	fn name(&self) -> Result<string> {822		Ok(decode_utf16(self.name.iter().copied())823			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))824			.collect::<string>())825	}826827	/// @notice An abbreviated name for NFTs in this contract828	fn symbol(&self) -> Result<string> {829		Ok(string::from_utf8_lossy(&self.token_prefix).into())830	}831832	/// @notice A description for the collection.833	fn description(&self) -> Result<string> {834		Ok(decode_utf16(self.description.iter().copied())835			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))836			.collect::<string>())837	}838839	/// Returns the owner (in cross format) of the token.840	///841	/// @param tokenId Id for the token.842	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {843		Self::token_owner(&self, token_id.try_into()?)844			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))845			.ok_or(Error::Revert("key too large".into()))846	}847848	/// Returns the token properties.849	///850	/// @param tokenId Id for the token.851	/// @param keys Properties keys. Empty keys for all propertyes.852	/// @return Vector of properties key/value pairs.853	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {854		let keys = keys855			.into_iter()856			.map(|key| {857				<Vec<u8>>::from(key)858					.try_into()859					.map_err(|_| Error::Revert("key too large".into()))860			})861			.collect::<Result<Vec<_>>>()?;862863		<Self as CommonCollectionOperations<T>>::token_properties(864			&self,865			token_id.try_into()?,866			if keys.is_empty() { None } else { Some(keys) },867		)868		.into_iter()869		.map(|p| {870			let key = string::from_utf8(p.key.to_vec())871				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;872			let value = bytes(p.value.to_vec());873			Ok(PropertyStruct { key, value })874		})875		.collect::<Result<Vec<_>>>()876	}877	/// @notice Transfer ownership of an RFT878	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`879	///  is the zero address. Throws if `tokenId` is not a valid RFT.880	///  Throws if RFT pieces have multiple owners.881	/// @param to The new owner882	/// @param tokenId The RFT to transfer883	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]884	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {885		let caller = T::CrossAccountId::from_eth(caller);886		let to = T::CrossAccountId::from_eth(to);887		let token = token_id.try_into()?;888		let budget = self889			.recorder890			.weight_calls_budget(<StructureWeight<T>>::find_parent());891892		let balance = balance(self, token, &caller)?;893		ensure_single_owner(self, token, balance)?;894895		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)896			.map_err(dispatch_to_evm::<T>)?;897		Ok(())898	}899900	/// @notice Transfer ownership of an RFT901	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`902	///  is the zero address. Throws if `tokenId` is not a valid RFT.903	///  Throws if RFT pieces have multiple owners.904	/// @param to The new owner905	/// @param tokenId The RFT to transfer906	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]907	fn transfer_cross(908		&mut self,909		caller: caller,910		to: EthCrossAccount,911		token_id: uint256,912	) -> Result<void> {913		let caller = T::CrossAccountId::from_eth(caller);914		let to = to.into_sub_cross_account::<T>()?;915		let token = token_id.try_into()?;916		let budget = self917			.recorder918			.weight_calls_budget(<StructureWeight<T>>::find_parent());919920		let balance = balance(self, token, &caller)?;921		ensure_single_owner(self, token, balance)?;922923		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)924			.map_err(dispatch_to_evm::<T>)?;925		Ok(())926	}927928	/// @notice Transfer ownership of an RFT929	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`930	///  is the zero address. Throws if `tokenId` is not a valid RFT.931	///  Throws if RFT pieces have multiple owners.932	/// @param to The new owner933	/// @param tokenId The RFT to transfer934	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]935	fn transfer_from_cross(936		&mut self,937		caller: caller,938		from: EthCrossAccount,939		to: EthCrossAccount,940		token_id: uint256,941	) -> Result<void> {942		let caller = T::CrossAccountId::from_eth(caller);943		let from = from.into_sub_cross_account::<T>()?;944		let to = to.into_sub_cross_account::<T>()?;945		let token_id = token_id.try_into()?;946		let budget = self947			.recorder948			.weight_calls_budget(<StructureWeight<T>>::find_parent());949950		let balance = balance(self, token_id, &from)?;951		ensure_single_owner(self, token_id, balance)?;952953		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)954			.map_err(dispatch_to_evm::<T>)?;955		Ok(())956	}957958	/// @notice Burns a specific ERC721 token.959	/// @dev Throws unless `msg.sender` is the current owner or an authorized960	///  operator for this RFT. Throws if `from` is not the current owner. Throws961	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.962	///  Throws if RFT pieces have multiple owners.963	/// @param from The current owner of the RFT964	/// @param tokenId The RFT to transfer965	#[solidity(hide)]966	#[weight(<SelfWeightOf<T>>::burn_from())]967	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {968		let caller = T::CrossAccountId::from_eth(caller);969		let from = T::CrossAccountId::from_eth(from);970		let token = token_id.try_into()?;971		let budget = self972			.recorder973			.weight_calls_budget(<StructureWeight<T>>::find_parent());974975		let balance = balance(self, token, &from)?;976		ensure_single_owner(self, token, balance)?;977978		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)979			.map_err(dispatch_to_evm::<T>)?;980		Ok(())981	}982983	/// @notice Burns a specific ERC721 token.984	/// @dev Throws unless `msg.sender` is the current owner or an authorized985	///  operator for this RFT. Throws if `from` is not the current owner. Throws986	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.987	///  Throws if RFT pieces have multiple owners.988	/// @param from The current owner of the RFT989	/// @param tokenId The RFT to transfer990	#[weight(<SelfWeightOf<T>>::burn_from())]991	fn burn_from_cross(992		&mut self,993		caller: caller,994		from: EthCrossAccount,995		token_id: uint256,996	) -> Result<void> {997		let caller = T::CrossAccountId::from_eth(caller);998		let from = from.into_sub_cross_account::<T>()?;999		let token = token_id.try_into()?;1000		let budget = self1001			.recorder1002			.weight_calls_budget(<StructureWeight<T>>::find_parent());10031004		let balance = balance(self, token, &from)?;1005		ensure_single_owner(self, token, balance)?;10061007		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)1008			.map_err(dispatch_to_evm::<T>)?;1009		Ok(())1010	}10111012	/// @notice Returns next free RFT ID.1013	fn next_token_id(&self) -> Result<uint256> {1014		self.consume_store_reads(1)?;1015		Ok(<TokensMinted<T>>::get(self.id)1016			.checked_add(1)1017			.ok_or("item id overflow")?1018			.into())1019	}10201021	/// @notice Function to mint multiple tokens.1022	/// @dev `tokenIds` should be an array of consecutive numbers and first number1023	///  should be obtained with `nextTokenId` method1024	/// @param to The new owner1025	/// @param tokenIds IDs of the minted RFTs1026	#[solidity(hide)]1027	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]1028	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {1029		let caller = T::CrossAccountId::from_eth(caller);1030		let to = T::CrossAccountId::from_eth(to);1031		let mut expected_index = <TokensMinted<T>>::get(self.id)1032			.checked_add(1)1033			.ok_or("item id overflow")?;1034		let budget = self1035			.recorder1036			.weight_calls_budget(<StructureWeight<T>>::find_parent());10371038		let total_tokens = token_ids.len();1039		for id in token_ids.into_iter() {1040			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1041			if id != expected_index {1042				return Err("item id should be next".into());1043			}1044			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1045		}1046		let users = [(to.clone(), 1)]1047			.into_iter()1048			.collect::<BTreeMap<_, _>>()1049			.try_into()1050			.unwrap();1051		let create_item_data = CreateItemData::<T> {1052			users,1053			properties: CollectionPropertiesVec::default(),1054		};1055		let data = (0..total_tokens)1056			.map(|_| create_item_data.clone())1057			.collect();10581059		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1060			.map_err(dispatch_to_evm::<T>)?;1061		Ok(true)1062	}10631064	/// @notice Function to mint multiple tokens with the given tokenUris.1065	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1066	///  numbers and first number should be obtained with `nextTokenId` method1067	/// @param to The new owner1068	/// @param tokens array of pairs of token ID and token URI for minted tokens1069	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1070	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1071	fn mint_bulk_with_token_uri(1072		&mut self,1073		caller: caller,1074		to: address,1075		tokens: Vec<(uint256, string)>,1076	) -> Result<bool> {1077		let key = key::url();1078		let caller = T::CrossAccountId::from_eth(caller);1079		let to = T::CrossAccountId::from_eth(to);1080		let mut expected_index = <TokensMinted<T>>::get(self.id)1081			.checked_add(1)1082			.ok_or("item id overflow")?;1083		let budget = self1084			.recorder1085			.weight_calls_budget(<StructureWeight<T>>::find_parent());10861087		let mut data = Vec::with_capacity(tokens.len());1088		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1089			.into_iter()1090			.collect::<BTreeMap<_, _>>()1091			.try_into()1092			.unwrap();1093		for (id, token_uri) in tokens {1094			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1095			if id != expected_index {1096				return Err("item id should be next".into());1097			}1098			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10991100			let mut properties = CollectionPropertiesVec::default();1101			properties1102				.try_push(Property {1103					key: key.clone(),1104					value: token_uri1105						.into_bytes()1106						.try_into()1107						.map_err(|_| "token uri is too long")?,1108				})1109				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;11101111			let create_item_data = CreateItemData::<T> {1112				users: users.clone(),1113				properties,1114			};1115			data.push(create_item_data);1116		}11171118		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1119			.map_err(dispatch_to_evm::<T>)?;1120		Ok(true)1121	}11221123	/// @notice Function to mint a token.1124	/// @param to The new owner crossAccountId1125	/// @param properties Properties of minted token1126	/// @return uint256 The id of the newly minted token1127	#[weight(<SelfWeightOf<T>>::create_item())]1128	fn mint_cross(1129		&mut self,1130		caller: caller,1131		to: EthCrossAccount,1132		properties: Vec<PropertyStruct>,1133	) -> Result<uint256> {1134		let token_id = <TokensMinted<T>>::get(self.id)1135			.checked_add(1)1136			.ok_or("item id overflow")?;11371138		let to = to.into_sub_cross_account::<T>()?;11391140		let properties = properties1141			.into_iter()1142			.map(|PropertyStruct { key, value }| {1143				let key = <Vec<u8>>::from(key)1144					.try_into()1145					.map_err(|_| "key too large")?;11461147				let value = value.0.try_into().map_err(|_| "value too large")?;11481149				Ok(Property { key, value })1150			})1151			.collect::<Result<Vec<_>>>()?1152			.try_into()1153			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;11541155		let caller = T::CrossAccountId::from_eth(caller);11561157		let budget = self1158			.recorder1159			.weight_calls_budget(<StructureWeight<T>>::find_parent());11601161		let users = [(to, 1)]1162			.into_iter()1163			.collect::<BTreeMap<_, _>>()1164			.try_into()1165			.unwrap();1166		<Pallet<T>>::create_item(1167			self,1168			&caller,1169			CreateItemData::<T> { users, properties },1170			&budget,1171		)1172		.map_err(dispatch_to_evm::<T>)?;11731174		Ok(token_id.into())1175	}11761177	/// Returns EVM address for refungible token1178	///1179	/// @param token ID of the token1180	fn token_contract_address(&self, token: uint256) -> Result<address> {1181		Ok(T::EvmTokenAddressMapping::token_to_address(1182			self.id,1183			token.try_into().map_err(|_| "token id overflow")?,1184		))1185	}1186}11871188#[solidity_interface(1189	name = UniqueRefungible,1190	is(1191		ERC721,1192		ERC721Enumerable,1193		ERC721UniqueExtensions,1194		ERC721UniqueMintable,1195		ERC721Burnable,1196		ERC721Metadata(if(this.flags.erc721metadata)),1197		Collection(via(common_mut returns CollectionHandle<T>)),1198		TokenProperties,1199	)1200)]1201impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}12021203// Not a tests, but code generators1204generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1205generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);12061207impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1208where1209	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1210{1211	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1212	fn call(1213		self,1214		handle: &mut impl PrecompileHandle,1215	) -> Option<pallet_common::erc::PrecompileResult> {1216		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1217	}1218}