git.delta.rocks / unique-network / refs/commits / 03209c26cefb

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,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	fn set_token_property_permission(66		&mut self,67		caller: caller,68		key: string,69		is_mutable: bool,70		collection_admin: bool,71		token_owner: bool,72	) -> Result<()> {73		let caller = T::CrossAccountId::from_eth(caller);74		<Pallet<T>>::set_token_property_permissions(75			self,76			&caller,77			vec![PropertyKeyPermission {78				key: <Vec<u8>>::from(key)79					.try_into()80					.map_err(|_| "too long key")?,81				permission: PropertyPermission {82					mutable: is_mutable,83					collection_admin,84					token_owner,85				},86			}],87		)88		.map_err(dispatch_to_evm::<T>)89	}9091	/// @notice Set token property value.92	/// @dev Throws error if `msg.sender` has no permission to edit the property.93	/// @param tokenId ID of the token.94	/// @param key Property key.95	/// @param value Property value.96	#[solidity(hide)]97	fn set_property(98		&mut self,99		caller: caller,100		token_id: uint256,101		key: string,102		value: bytes,103	) -> Result<()> {104		let caller = T::CrossAccountId::from_eth(caller);105		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;106		let key = <Vec<u8>>::from(key)107			.try_into()108			.map_err(|_| "key too long")?;109		let value = value.0.try_into().map_err(|_| "value too long")?;110111		let nesting_budget = self112			.recorder113			.weight_calls_budget(<StructureWeight<T>>::find_parent());114115		<Pallet<T>>::set_token_property(116			self,117			&caller,118			TokenId(token_id),119			Property { key, value },120			&nesting_budget,121		)122		.map_err(dispatch_to_evm::<T>)123	}124125	/// @notice Set token properties value.126	/// @dev Throws error if `msg.sender` has no permission to edit the property.127	/// @param tokenId ID of the token.128	/// @param properties settable properties129	fn set_properties(130		&mut self,131		caller: caller,132		token_id: uint256,133		properties: Vec<PropertyStruct>,134	) -> Result<()> {135		let caller = T::CrossAccountId::from_eth(caller);136		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;137138		let nesting_budget = self139			.recorder140			.weight_calls_budget(<StructureWeight<T>>::find_parent());141142		let properties = properties143			.into_iter()144			.map(|PropertyStruct { key, value }| {145				let key = <Vec<u8>>::from(key)146					.try_into()147					.map_err(|_| "key too large")?;148149				let value = value.0.try_into().map_err(|_| "value too large")?;150151				Ok(Property { key, value })152			})153			.collect::<Result<Vec<_>>>()?;154155		<Pallet<T>>::set_token_properties(156			self,157			&caller,158			TokenId(token_id),159			properties.into_iter(),160			false,161			&nesting_budget,162		)163		.map_err(dispatch_to_evm::<T>)164	}165166	/// @notice Delete token property value.167	/// @dev Throws error if `msg.sender` has no permission to edit the property.168	/// @param tokenId ID of the token.169	/// @param key Property key.170	#[solidity(hide)]171	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {172		let caller = T::CrossAccountId::from_eth(caller);173		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;174		let key = <Vec<u8>>::from(key)175			.try_into()176			.map_err(|_| "key too long")?;177178		let nesting_budget = self179			.recorder180			.weight_calls_budget(<StructureWeight<T>>::find_parent());181182		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)183			.map_err(dispatch_to_evm::<T>)184	}185186	/// @notice Delete token properties value.187	/// @dev Throws error if `msg.sender` has no permission to edit the property.188	/// @param tokenId ID of the token.189	/// @param keys Properties key.190	fn delete_properties(191		&mut self,192		token_id: uint256,193		caller: caller,194		keys: Vec<string>,195	) -> Result<()> {196		let caller = T::CrossAccountId::from_eth(caller);197		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;198		let keys = keys199			.into_iter()200			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))201			.collect::<Result<Vec<_>>>()?;202203		let nesting_budget = self204			.recorder205			.weight_calls_budget(<StructureWeight<T>>::find_parent());206207		<Pallet<T>>::delete_token_properties(208			self,209			&caller,210			TokenId(token_id),211			keys.into_iter(),212			&nesting_budget,213		)214		.map_err(dispatch_to_evm::<T>)215	}216217	/// @notice Get token property value.218	/// @dev Throws error if key not found219	/// @param tokenId ID of the token.220	/// @param key Property key.221	/// @return Property value bytes222	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {223		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;224		let key = <Vec<u8>>::from(key)225			.try_into()226			.map_err(|_| "key too long")?;227228		let props = <TokenProperties<T>>::get((self.id, token_id));229		let prop = props.get(&key).ok_or("key not found")?;230231		Ok(prop.to_vec().into())232	}233}234235#[derive(ToLog)]236pub enum ERC721Events {237	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed238	///  (`to` == 0). Exception: during contract creation, any number of RFTs239	///  may be created and assigned without emitting Transfer.240	Transfer {241		#[indexed]242		from: address,243		#[indexed]244		to: address,245		#[indexed]246		token_id: uint256,247	},248	/// @dev Not supported249	Approval {250		#[indexed]251		owner: address,252		#[indexed]253		approved: address,254		#[indexed]255		token_id: uint256,256	},257	/// @dev Not supported258	#[allow(dead_code)]259	ApprovalForAll {260		#[indexed]261		owner: address,262		#[indexed]263		operator: address,264		approved: bool,265	},266}267268#[derive(ToLog)]269pub enum ERC721UniqueMintableEvents {270	/// @dev Not supported271	#[allow(dead_code)]272	MintingFinished {},273}274275#[solidity_interface(name = ERC721Metadata)]276impl<T: Config> RefungibleHandle<T>277where278	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,279{280	/// @notice A descriptive name for a collection of NFTs in this contract281	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`282	#[solidity(hide, rename_selector = "name")]283	fn name_proxy(&self) -> Result<string> {284		self.name()285	}286287	/// @notice An abbreviated name for NFTs in this contract288	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`289	#[solidity(hide, rename_selector = "symbol")]290	fn symbol_proxy(&self) -> Result<string> {291		self.symbol()292	}293294	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.295	///296	/// @dev If the token has a `url` property and it is not empty, it is returned.297	///  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`.298	///  If the collection property `baseURI` is empty or absent, return "" (empty string)299	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix300	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).301	///302	/// @return token's const_metadata303	#[solidity(rename_selector = "tokenURI")]304	fn token_uri(&self, token_id: uint256) -> Result<string> {305		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;306307		match get_token_property(self, token_id_u32, &key::url()).as_deref() {308			Err(_) | Ok("") => (),309			Ok(url) => {310				return Ok(url.into());311			}312		};313314		let base_uri =315			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())316				.map(BoundedVec::into_inner)317				.map(string::from_utf8)318				.transpose()319				.map_err(|e| {320					Error::Revert(alloc::format!(321						"Can not convert value \"baseURI\" to string with error \"{}\"",322						e323					))324				})?;325326		let base_uri = match base_uri.as_deref() {327			None | Some("") => {328				return Ok("".into());329			}330			Some(base_uri) => base_uri.into(),331		};332333		Ok(334			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {335				Err(_) | Ok("") => base_uri,336				Ok(suffix) => base_uri + suffix,337			},338		)339	}340}341342/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension343/// @dev See https://eips.ethereum.org/EIPS/eip-721344#[solidity_interface(name = ERC721Enumerable)]345impl<T: Config> RefungibleHandle<T> {346	/// @notice Enumerate valid RFTs347	/// @param index A counter less than `totalSupply()`348	/// @return The token identifier for the `index`th NFT,349	///  (sort order not specified)350	fn token_by_index(&self, index: uint256) -> Result<uint256> {351		Ok(index)352	}353354	/// Not implemented355	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {356		// TODO: Not implemetable357		Err("not implemented".into())358	}359360	/// @notice Count RFTs tracked by this contract361	/// @return A count of valid RFTs tracked by this contract, where each one of362	///  them has an assigned and queryable owner not equal to the zero address363	fn total_supply(&self) -> Result<uint256> {364		self.consume_store_reads(1)?;365		Ok(<Pallet<T>>::total_supply(self).into())366	}367}368369/// @title ERC-721 Non-Fungible Token Standard370/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md371#[solidity_interface(name = ERC721, events(ERC721Events))]372impl<T: Config> RefungibleHandle<T> {373	/// @notice Count all RFTs assigned to an owner374	/// @dev RFTs assigned to the zero address are considered invalid, and this375	///  function throws for queries about the zero address.376	/// @param owner An address for whom to query the balance377	/// @return The number of RFTs owned by `owner`, possibly zero378	fn balance_of(&self, owner: address) -> Result<uint256> {379		self.consume_store_reads(1)?;380		let owner = T::CrossAccountId::from_eth(owner);381		let balance = <AccountBalance<T>>::get((self.id, owner));382		Ok(balance.into())383	}384385	/// @notice Find the owner of an RFT386	/// @dev RFTs assigned to zero address are considered invalid, and queries387	///  about them do throw.388	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for389	///  the tokens that are partially owned.390	/// @param tokenId The identifier for an RFT391	/// @return The address of the owner of the RFT392	fn owner_of(&self, token_id: uint256) -> Result<address> {393		self.consume_store_reads(2)?;394		let token = token_id.try_into()?;395		let owner = <Pallet<T>>::token_owner(self.id, token);396		Ok(owner397			.map(|address| *address.as_eth())398			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))399	}400401	/// @dev Not implemented402	fn safe_transfer_from_with_data(403		&mut self,404		_from: address,405		_to: address,406		_token_id: uint256,407		_data: bytes,408	) -> Result<void> {409		// TODO: Not implemetable410		Err("not implemented".into())411	}412413	/// @dev Not implemented414	fn safe_transfer_from(415		&mut self,416		_from: address,417		_to: address,418		_token_id: uint256,419	) -> Result<void> {420		// TODO: Not implemetable421		Err("not implemented".into())422	}423424	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE425	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE426	///  THEY MAY BE PERMANENTLY LOST427	/// @dev Throws unless `msg.sender` is the current owner or an authorized428	///  operator for this RFT. Throws if `from` is not the current owner. Throws429	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.430	///  Throws if RFT pieces have multiple owners.431	/// @param from The current owner of the NFT432	/// @param to The new owner433	/// @param tokenId The NFT to transfer434	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]435	fn transfer_from(436		&mut self,437		caller: caller,438		from: address,439		to: address,440		token_id: uint256,441	) -> Result<void> {442		let caller = T::CrossAccountId::from_eth(caller);443		let from = T::CrossAccountId::from_eth(from);444		let to = T::CrossAccountId::from_eth(to);445		let token = token_id.try_into()?;446		let budget = self447			.recorder448			.weight_calls_budget(<StructureWeight<T>>::find_parent());449450		let balance = balance(&self, token, &from)?;451		ensure_single_owner(&self, token, balance)?;452453		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)454			.map_err(dispatch_to_evm::<T>)?;455456		Ok(())457	}458459	/// @dev Not implemented460	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {461		Err("not implemented".into())462	}463464	/// @notice Sets or unsets the approval of a given operator.465	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.466	/// @param operator Operator467	/// @param approved Should operator status be granted or revoked?468	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]469	fn set_approval_for_all(470		&mut self,471		caller: caller,472		operator: address,473		approved: bool,474	) -> Result<void> {475		let caller = T::CrossAccountId::from_eth(caller);476		let operator = T::CrossAccountId::from_eth(operator);477478		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)479			.map_err(dispatch_to_evm::<T>)?;480		Ok(())481	}482483	/// @dev Not implemented484	fn get_approved(&self, _token_id: uint256) -> Result<address> {485		// TODO: Not implemetable486		Err("not implemented".into())487	}488489	/// @notice Tells whether the given `owner` approves the `operator`.490	#[weight(<SelfWeightOf<T>>::allowance_for_all())]491	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {492		let owner = T::CrossAccountId::from_eth(owner);493		let operator = T::CrossAccountId::from_eth(operator);494495		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))496	}497498	/// @notice Returns collection helper contract address499	fn collection_helper_address(&self) -> Result<address> {500		Ok(T::ContractAddress::get())501	}502}503504/// Returns amount of pieces of `token` that `owner` have505pub fn balance<T: Config>(506	collection: &RefungibleHandle<T>,507	token: TokenId,508	owner: &T::CrossAccountId,509) -> Result<u128> {510	collection.consume_store_reads(1)?;511	let balance = <Balance<T>>::get((collection.id, token, &owner));512	Ok(balance)513}514515/// Throws if `owner_balance` is lower than total amount of `token` pieces516pub fn ensure_single_owner<T: Config>(517	collection: &RefungibleHandle<T>,518	token: TokenId,519	owner_balance: u128,520) -> Result<()> {521	collection.consume_store_reads(1)?;522	let total_supply = <TotalSupply<T>>::get((collection.id, token));523524	if owner_balance == 0 {525		return Err(dispatch_to_evm::<T>(526			<CommonError<T>>::MustBeTokenOwner.into(),527		));528	}529530	if total_supply != owner_balance {531		return Err("token has multiple owners".into());532	}533	Ok(())534}535536/// @title ERC721 Token that can be irreversibly burned (destroyed).537#[solidity_interface(name = ERC721Burnable)]538impl<T: Config> RefungibleHandle<T> {539	/// @notice Burns a specific ERC721 token.540	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized541	///  operator of the current owner.542	/// @param tokenId The RFT to approve543	#[weight(<SelfWeightOf<T>>::burn_item_fully())]544	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {545		let caller = T::CrossAccountId::from_eth(caller);546		let token = token_id.try_into()?;547548		let balance = balance(&self, token, &caller)?;549		ensure_single_owner(&self, token, balance)?;550551		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;552		Ok(())553	}554}555556/// @title ERC721 minting logic.557#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]558impl<T: Config> RefungibleHandle<T> {559	fn minting_finished(&self) -> Result<bool> {560		Ok(false)561	}562563	/// @notice Function to mint token.564	/// @param to The new owner565	/// @return uint256 The id of the newly minted token566	#[weight(<SelfWeightOf<T>>::create_item())]567	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {568		let token_id: uint256 = <TokensMinted<T>>::get(self.id)569			.checked_add(1)570			.ok_or("item id overflow")?571			.into();572		self.mint_check_id(caller, to, token_id)?;573		Ok(token_id)574	}575576	/// @notice Function to mint token.577	/// @dev `tokenId` should be obtained with `nextTokenId` method,578	///  unlike standard, you can't specify it manually579	/// @param to The new owner580	/// @param tokenId ID of the minted RFT581	#[solidity(hide, rename_selector = "mint")]582	#[weight(<SelfWeightOf<T>>::create_item())]583	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {584		let caller = T::CrossAccountId::from_eth(caller);585		let to = T::CrossAccountId::from_eth(to);586		let token_id: u32 = token_id.try_into()?;587		let budget = self588			.recorder589			.weight_calls_budget(<StructureWeight<T>>::find_parent());590591		if <TokensMinted<T>>::get(self.id)592			.checked_add(1)593			.ok_or("item id overflow")?594			!= token_id595		{596			return Err("item id should be next".into());597		}598599		let users = [(to.clone(), 1)]600			.into_iter()601			.collect::<BTreeMap<_, _>>()602			.try_into()603			.unwrap();604		<Pallet<T>>::create_item(605			self,606			&caller,607			CreateItemData::<T::CrossAccountId> {608				users,609				properties: CollectionPropertiesVec::default(),610			},611			&budget,612		)613		.map_err(dispatch_to_evm::<T>)?;614615		Ok(true)616	}617618	/// @notice Function to mint token with the given tokenUri.619	/// @param to The new owner620	/// @param tokenUri Token URI that would be stored in the NFT properties621	/// @return uint256 The id of the newly minted token622	#[solidity(rename_selector = "mintWithTokenURI")]623	#[weight(<SelfWeightOf<T>>::create_item())]624	fn mint_with_token_uri(625		&mut self,626		caller: caller,627		to: address,628		token_uri: string,629	) -> Result<uint256> {630		let token_id: uint256 = <TokensMinted<T>>::get(self.id)631			.checked_add(1)632			.ok_or("item id overflow")?633			.into();634		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;635		Ok(token_id)636	}637638	/// @notice Function to mint token with the given tokenUri.639	/// @dev `tokenId` should be obtained with `nextTokenId` method,640	///  unlike standard, you can't specify it manually641	/// @param to The new owner642	/// @param tokenId ID of the minted RFT643	/// @param tokenUri Token URI that would be stored in the RFT properties644	#[solidity(hide, rename_selector = "mintWithTokenURI")]645	#[weight(<SelfWeightOf<T>>::create_item())]646	fn mint_with_token_uri_check_id(647		&mut self,648		caller: caller,649		to: address,650		token_id: uint256,651		token_uri: string,652	) -> Result<bool> {653		let key = key::url();654		let permission = get_token_permission::<T>(self.id, &key)?;655		if !permission.collection_admin {656			return Err("Operation is not allowed".into());657		}658659		let caller = T::CrossAccountId::from_eth(caller);660		let to = T::CrossAccountId::from_eth(to);661		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;662		let budget = self663			.recorder664			.weight_calls_budget(<StructureWeight<T>>::find_parent());665666		if <TokensMinted<T>>::get(self.id)667			.checked_add(1)668			.ok_or("item id overflow")?669			!= token_id670		{671			return Err("item id should be next".into());672		}673674		let mut properties = CollectionPropertiesVec::default();675		properties676			.try_push(Property {677				key,678				value: token_uri679					.into_bytes()680					.try_into()681					.map_err(|_| "token uri is too long")?,682			})683			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;684685		let users = [(to.clone(), 1)]686			.into_iter()687			.collect::<BTreeMap<_, _>>()688			.try_into()689			.unwrap();690		<Pallet<T>>::create_item(691			self,692			&caller,693			CreateItemData::<T::CrossAccountId> { users, properties },694			&budget,695		)696		.map_err(dispatch_to_evm::<T>)?;697		Ok(true)698	}699700	/// @dev Not implemented701	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {702		Err("not implementable".into())703	}704}705706fn get_token_property<T: Config>(707	collection: &CollectionHandle<T>,708	token_id: u32,709	key: &up_data_structs::PropertyKey,710) -> Result<string> {711	collection.consume_store_reads(1)?;712	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))713		.map_err(|_| Error::Revert("Token properties not found".into()))?;714	if let Some(property) = properties.get(key) {715		return Ok(string::from_utf8_lossy(property).into());716	}717718	Err("Property tokenURI not found".into())719}720721fn get_token_permission<T: Config>(722	collection_id: CollectionId,723	key: &PropertyKey,724) -> Result<PropertyPermission> {725	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)726		.map_err(|_| Error::Revert("No permissions for collection".into()))?;727	let a = token_property_permissions728		.get(key)729		.map(Clone::clone)730		.ok_or_else(|| {731			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();732			Error::Revert(alloc::format!("No permission for key {}", key))733		})?;734	Ok(a)735}736737/// @title Unique extensions for ERC721.738#[solidity_interface(name = ERC721UniqueExtensions)]739impl<T: Config> RefungibleHandle<T>740where741	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,742{743	/// @notice A descriptive name for a collection of NFTs in this contract744	fn name(&self) -> Result<string> {745		Ok(decode_utf16(self.name.iter().copied())746			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))747			.collect::<string>())748	}749750	/// @notice An abbreviated name for NFTs in this contract751	fn symbol(&self) -> Result<string> {752		Ok(string::from_utf8_lossy(&self.token_prefix).into())753	}754755	/// @notice A description for the collection.756	fn description(&self) -> Result<string> {757		Ok(decode_utf16(self.description.iter().copied())758			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))759			.collect::<string>())760	}761762	/// Returns the owner (in cross format) of the token.763	///764	/// @param tokenId Id for the token.765	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {766		Self::token_owner(&self, token_id.try_into()?)767			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))768			.ok_or(Error::Revert("key too large".into()))769	}770771	/// Returns the token properties.772	///773	/// @param tokenId Id for the token.774	/// @param keys Properties keys. Empty keys for all propertyes.775	/// @return Vector of properties key/value pairs.776	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {777		let keys = keys778			.into_iter()779			.map(|key| {780				<Vec<u8>>::from(key)781					.try_into()782					.map_err(|_| Error::Revert("key too large".into()))783			})784			.collect::<Result<Vec<_>>>()?;785786		<Self as CommonCollectionOperations<T>>::token_properties(787			&self,788			token_id.try_into()?,789			if keys.is_empty() { None } else { Some(keys) },790		)791		.into_iter()792		.map(|p| {793			let key = string::from_utf8(p.key.to_vec())794				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;795			let value = bytes(p.value.to_vec());796			Ok(PropertyStruct { key, value })797		})798		.collect::<Result<Vec<_>>>()799	}800	/// @notice Transfer ownership of an RFT801	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`802	///  is the zero address. Throws if `tokenId` is not a valid RFT.803	///  Throws if RFT pieces have multiple owners.804	/// @param to The new owner805	/// @param tokenId The RFT to transfer806	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]807	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {808		let caller = T::CrossAccountId::from_eth(caller);809		let to = T::CrossAccountId::from_eth(to);810		let token = token_id.try_into()?;811		let budget = self812			.recorder813			.weight_calls_budget(<StructureWeight<T>>::find_parent());814815		let balance = balance(self, token, &caller)?;816		ensure_single_owner(self, token, balance)?;817818		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)819			.map_err(dispatch_to_evm::<T>)?;820		Ok(())821	}822823	/// @notice Transfer ownership of an RFT824	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`825	///  is the zero address. Throws if `tokenId` is not a valid RFT.826	///  Throws if RFT pieces have multiple owners.827	/// @param to The new owner828	/// @param tokenId The RFT to transfer829	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]830	fn transfer_cross(831		&mut self,832		caller: caller,833		to: EthCrossAccount,834		token_id: uint256,835	) -> Result<void> {836		let caller = T::CrossAccountId::from_eth(caller);837		let to = to.into_sub_cross_account::<T>()?;838		let token = token_id.try_into()?;839		let budget = self840			.recorder841			.weight_calls_budget(<StructureWeight<T>>::find_parent());842843		let balance = balance(self, token, &caller)?;844		ensure_single_owner(self, token, balance)?;845846		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)847			.map_err(dispatch_to_evm::<T>)?;848		Ok(())849	}850851	/// @notice Transfer ownership of an RFT852	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`853	///  is the zero address. Throws if `tokenId` is not a valid RFT.854	///  Throws if RFT pieces have multiple owners.855	/// @param to The new owner856	/// @param tokenId The RFT to transfer857	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]858	fn transfer_from_cross(859		&mut self,860		caller: caller,861		from: EthCrossAccount,862		to: EthCrossAccount,863		token_id: uint256,864	) -> Result<void> {865		let caller = T::CrossAccountId::from_eth(caller);866		let from = from.into_sub_cross_account::<T>()?;867		let to = to.into_sub_cross_account::<T>()?;868		let token_id = token_id.try_into()?;869		let budget = self870			.recorder871			.weight_calls_budget(<StructureWeight<T>>::find_parent());872873		let balance = balance(self, token_id, &from)?;874		ensure_single_owner(self, token_id, balance)?;875876		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)877			.map_err(dispatch_to_evm::<T>)?;878		Ok(())879	}880881	/// @notice Burns a specific ERC721 token.882	/// @dev Throws unless `msg.sender` is the current owner or an authorized883	///  operator for this RFT. Throws if `from` is not the current owner. Throws884	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.885	///  Throws if RFT pieces have multiple owners.886	/// @param from The current owner of the RFT887	/// @param tokenId The RFT to transfer888	#[solidity(hide)]889	#[weight(<SelfWeightOf<T>>::burn_from())]890	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {891		let caller = T::CrossAccountId::from_eth(caller);892		let from = T::CrossAccountId::from_eth(from);893		let token = token_id.try_into()?;894		let budget = self895			.recorder896			.weight_calls_budget(<StructureWeight<T>>::find_parent());897898		let balance = balance(self, token, &from)?;899		ensure_single_owner(self, token, balance)?;900901		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)902			.map_err(dispatch_to_evm::<T>)?;903		Ok(())904	}905906	/// @notice Burns a specific ERC721 token.907	/// @dev Throws unless `msg.sender` is the current owner or an authorized908	///  operator for this RFT. Throws if `from` is not the current owner. Throws909	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.910	///  Throws if RFT pieces have multiple owners.911	/// @param from The current owner of the RFT912	/// @param tokenId The RFT to transfer913	#[weight(<SelfWeightOf<T>>::burn_from())]914	fn burn_from_cross(915		&mut self,916		caller: caller,917		from: EthCrossAccount,918		token_id: uint256,919	) -> Result<void> {920		let caller = T::CrossAccountId::from_eth(caller);921		let from = from.into_sub_cross_account::<T>()?;922		let token = token_id.try_into()?;923		let budget = self924			.recorder925			.weight_calls_budget(<StructureWeight<T>>::find_parent());926927		let balance = balance(self, token, &from)?;928		ensure_single_owner(self, token, balance)?;929930		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)931			.map_err(dispatch_to_evm::<T>)?;932		Ok(())933	}934935	/// @notice Returns next free RFT ID.936	fn next_token_id(&self) -> Result<uint256> {937		self.consume_store_reads(1)?;938		Ok(<TokensMinted<T>>::get(self.id)939			.checked_add(1)940			.ok_or("item id overflow")?941			.into())942	}943944	/// @notice Function to mint multiple tokens.945	/// @dev `tokenIds` should be an array of consecutive numbers and first number946	///  should be obtained with `nextTokenId` method947	/// @param to The new owner948	/// @param tokenIds IDs of the minted RFTs949	#[solidity(hide)]950	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]951	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {952		let caller = T::CrossAccountId::from_eth(caller);953		let to = T::CrossAccountId::from_eth(to);954		let mut expected_index = <TokensMinted<T>>::get(self.id)955			.checked_add(1)956			.ok_or("item id overflow")?;957		let budget = self958			.recorder959			.weight_calls_budget(<StructureWeight<T>>::find_parent());960961		let total_tokens = token_ids.len();962		for id in token_ids.into_iter() {963			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;964			if id != expected_index {965				return Err("item id should be next".into());966			}967			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;968		}969		let users = [(to.clone(), 1)]970			.into_iter()971			.collect::<BTreeMap<_, _>>()972			.try_into()973			.unwrap();974		let create_item_data = CreateItemData::<T::CrossAccountId> {975			users,976			properties: CollectionPropertiesVec::default(),977		};978		let data = (0..total_tokens)979			.map(|_| create_item_data.clone())980			.collect();981982		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)983			.map_err(dispatch_to_evm::<T>)?;984		Ok(true)985	}986987	/// @notice Function to mint multiple tokens with the given tokenUris.988	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive989	///  numbers and first number should be obtained with `nextTokenId` method990	/// @param to The new owner991	/// @param tokens array of pairs of token ID and token URI for minted tokens992	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]993	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]994	fn mint_bulk_with_token_uri(995		&mut self,996		caller: caller,997		to: address,998		tokens: Vec<(uint256, string)>,999	) -> Result<bool> {1000		let key = key::url();1001		let caller = T::CrossAccountId::from_eth(caller);1002		let to = T::CrossAccountId::from_eth(to);1003		let mut expected_index = <TokensMinted<T>>::get(self.id)1004			.checked_add(1)1005			.ok_or("item id overflow")?;1006		let budget = self1007			.recorder1008			.weight_calls_budget(<StructureWeight<T>>::find_parent());10091010		let mut data = Vec::with_capacity(tokens.len());1011		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1012			.into_iter()1013			.collect::<BTreeMap<_, _>>()1014			.try_into()1015			.unwrap();1016		for (id, token_uri) in tokens {1017			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1018			if id != expected_index {1019				return Err("item id should be next".into());1020			}1021			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10221023			let mut properties = CollectionPropertiesVec::default();1024			properties1025				.try_push(Property {1026					key: key.clone(),1027					value: token_uri1028						.into_bytes()1029						.try_into()1030						.map_err(|_| "token uri is too long")?,1031				})1032				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10331034			let create_item_data = CreateItemData::<T::CrossAccountId> {1035				users: users.clone(),1036				properties,1037			};1038			data.push(create_item_data);1039		}10401041		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1042			.map_err(dispatch_to_evm::<T>)?;1043		Ok(true)1044	}10451046	/// Returns EVM address for refungible token1047	///1048	/// @param token ID of the token1049	fn token_contract_address(&self, token: uint256) -> Result<address> {1050		Ok(T::EvmTokenAddressMapping::token_to_address(1051			self.id,1052			token.try_into().map_err(|_| "token id overflow")?,1053		))1054	}1055}10561057#[solidity_interface(1058	name = UniqueRefungible,1059	is(1060		ERC721,1061		ERC721Enumerable,1062		ERC721UniqueExtensions,1063		ERC721UniqueMintable,1064		ERC721Burnable,1065		ERC721Metadata(if(this.flags.erc721metadata)),1066		Collection(via(common_mut returns CollectionHandle<T>)),1067		TokenProperties,1068	)1069)]1070impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10711072// Not a tests, but code generators1073generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1074generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);10751076impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1077where1078	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1079{1080	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1081	fn call(1082		self,1083		handle: &mut impl PrecompileHandle,1084	) -> Option<pallet_common::erc::PrecompileResult> {1085		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1086	}1087}