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

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			<Pallet<T>>::token_exists(&self, TokenId(token_id)),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	/// @dev Not implemented465	fn set_approval_for_all(466		&mut self,467		_caller: caller,468		_operator: address,469		_approved: bool,470	) -> Result<void> {471		// TODO: Not implemetable472		Err("not implemented".into())473	}474475	/// @dev Not implemented476	fn get_approved(&self, _token_id: uint256) -> Result<address> {477		// TODO: Not implemetable478		Err("not implemented".into())479	}480481	/// @dev Not implemented482	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {483		// TODO: Not implemetable484		Err("not implemented".into())485	}486487	/// @notice Returns collection helper contract address488	fn collection_helper_address(&self) -> Result<address> {489		Ok(T::ContractAddress::get())490	}491}492493/// Returns amount of pieces of `token` that `owner` have494pub fn balance<T: Config>(495	collection: &RefungibleHandle<T>,496	token: TokenId,497	owner: &T::CrossAccountId,498) -> Result<u128> {499	collection.consume_store_reads(1)?;500	let balance = <Balance<T>>::get((collection.id, token, &owner));501	Ok(balance)502}503504/// Throws if `owner_balance` is lower than total amount of `token` pieces505pub fn ensure_single_owner<T: Config>(506	collection: &RefungibleHandle<T>,507	token: TokenId,508	owner_balance: u128,509) -> Result<()> {510	collection.consume_store_reads(1)?;511	let total_supply = <TotalSupply<T>>::get((collection.id, token));512513	if owner_balance == 0 {514		return Err(dispatch_to_evm::<T>(515			<CommonError<T>>::MustBeTokenOwner.into(),516		));517	}518519	if total_supply != owner_balance {520		return Err("token has multiple owners".into());521	}522	Ok(())523}524525/// @title ERC721 Token that can be irreversibly burned (destroyed).526#[solidity_interface(name = ERC721Burnable)]527impl<T: Config> RefungibleHandle<T> {528	/// @notice Burns a specific ERC721 token.529	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized530	///  operator of the current owner.531	/// @param tokenId The RFT to approve532	#[weight(<SelfWeightOf<T>>::burn_item_fully())]533	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {534		let caller = T::CrossAccountId::from_eth(caller);535		let token = token_id.try_into()?;536537		let balance = balance(&self, token, &caller)?;538		ensure_single_owner(&self, token, balance)?;539540		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;541		Ok(())542	}543}544545/// @title ERC721 minting logic.546#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]547impl<T: Config> RefungibleHandle<T> {548	fn minting_finished(&self) -> Result<bool> {549		Ok(false)550	}551552	/// @notice Function to mint token.553	/// @param to The new owner554	/// @return uint256 The id of the newly minted token555	#[weight(<SelfWeightOf<T>>::create_item())]556	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {557		let token_id: uint256 = <TokensMinted<T>>::get(self.id)558			.checked_add(1)559			.ok_or("item id overflow")?560			.into();561		self.mint_check_id(caller, to, token_id)?;562		Ok(token_id)563	}564565	/// @notice Function to mint token.566	/// @dev `tokenId` should be obtained with `nextTokenId` method,567	///  unlike standard, you can't specify it manually568	/// @param to The new owner569	/// @param tokenId ID of the minted RFT570	#[solidity(hide, rename_selector = "mint")]571	#[weight(<SelfWeightOf<T>>::create_item())]572	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {573		let caller = T::CrossAccountId::from_eth(caller);574		let to = T::CrossAccountId::from_eth(to);575		let token_id: u32 = token_id.try_into()?;576		let budget = self577			.recorder578			.weight_calls_budget(<StructureWeight<T>>::find_parent());579580		if <TokensMinted<T>>::get(self.id)581			.checked_add(1)582			.ok_or("item id overflow")?583			!= token_id584		{585			return Err("item id should be next".into());586		}587588		let users = [(to.clone(), 1)]589			.into_iter()590			.collect::<BTreeMap<_, _>>()591			.try_into()592			.unwrap();593		<Pallet<T>>::create_item(594			self,595			&caller,596			CreateItemData::<T::CrossAccountId> {597				users,598				properties: CollectionPropertiesVec::default(),599			},600			&budget,601		)602		.map_err(dispatch_to_evm::<T>)?;603604		Ok(true)605	}606607	/// @notice Function to mint token with the given tokenUri.608	/// @param to The new owner609	/// @param tokenUri Token URI that would be stored in the NFT properties610	/// @return uint256 The id of the newly minted token611	#[solidity(rename_selector = "mintWithTokenURI")]612	#[weight(<SelfWeightOf<T>>::create_item())]613	fn mint_with_token_uri(614		&mut self,615		caller: caller,616		to: address,617		token_uri: string,618	) -> Result<uint256> {619		let token_id: uint256 = <TokensMinted<T>>::get(self.id)620			.checked_add(1)621			.ok_or("item id overflow")?622			.into();623		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;624		Ok(token_id)625	}626627	/// @notice Function to mint token with the given tokenUri.628	/// @dev `tokenId` should be obtained with `nextTokenId` method,629	///  unlike standard, you can't specify it manually630	/// @param to The new owner631	/// @param tokenId ID of the minted RFT632	/// @param tokenUri Token URI that would be stored in the RFT properties633	#[solidity(hide, rename_selector = "mintWithTokenURI")]634	#[weight(<SelfWeightOf<T>>::create_item())]635	fn mint_with_token_uri_check_id(636		&mut self,637		caller: caller,638		to: address,639		token_id: uint256,640		token_uri: string,641	) -> Result<bool> {642		let key = key::url();643		let permission = get_token_permission::<T>(self.id, &key)?;644		if !permission.collection_admin {645			return Err("Operation is not allowed".into());646		}647648		let caller = T::CrossAccountId::from_eth(caller);649		let to = T::CrossAccountId::from_eth(to);650		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;651		let budget = self652			.recorder653			.weight_calls_budget(<StructureWeight<T>>::find_parent());654655		if <TokensMinted<T>>::get(self.id)656			.checked_add(1)657			.ok_or("item id overflow")?658			!= token_id659		{660			return Err("item id should be next".into());661		}662663		let mut properties = CollectionPropertiesVec::default();664		properties665			.try_push(Property {666				key,667				value: token_uri668					.into_bytes()669					.try_into()670					.map_err(|_| "token uri is too long")?,671			})672			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;673674		let users = [(to.clone(), 1)]675			.into_iter()676			.collect::<BTreeMap<_, _>>()677			.try_into()678			.unwrap();679		<Pallet<T>>::create_item(680			self,681			&caller,682			CreateItemData::<T::CrossAccountId> { users, properties },683			&budget,684		)685		.map_err(dispatch_to_evm::<T>)?;686		Ok(true)687	}688689	/// @dev Not implemented690	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {691		Err("not implementable".into())692	}693}694695fn get_token_property<T: Config>(696	collection: &CollectionHandle<T>,697	token_id: u32,698	key: &up_data_structs::PropertyKey,699) -> Result<string> {700	collection.consume_store_reads(1)?;701	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))702		.map_err(|_| Error::Revert("Token properties not found".into()))?;703	if let Some(property) = properties.get(key) {704		return Ok(string::from_utf8_lossy(property).into());705	}706707	Err("Property tokenURI not found".into())708}709710fn get_token_permission<T: Config>(711	collection_id: CollectionId,712	key: &PropertyKey,713) -> Result<PropertyPermission> {714	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)715		.map_err(|_| Error::Revert("No permissions for collection".into()))?;716	let a = token_property_permissions717		.get(key)718		.map(Clone::clone)719		.ok_or_else(|| {720			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();721			Error::Revert(alloc::format!("No permission for key {}", key))722		})?;723	Ok(a)724}725726/// @title Unique extensions for ERC721.727#[solidity_interface(name = ERC721UniqueExtensions)]728impl<T: Config> RefungibleHandle<T>729where730	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,731{732	/// @notice A descriptive name for a collection of NFTs in this contract733	fn name(&self) -> Result<string> {734		Ok(decode_utf16(self.name.iter().copied())735			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))736			.collect::<string>())737	}738739	/// @notice An abbreviated name for NFTs in this contract740	fn symbol(&self) -> Result<string> {741		Ok(string::from_utf8_lossy(&self.token_prefix).into())742	}743744	/// @notice A description for the collection.745	fn description(&self) -> Result<string> {746		Ok(decode_utf16(self.description.iter().copied())747			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))748			.collect::<string>())749	}750751	/// Returns the owner (in cross format) of the token.752	///753	/// @param tokenId Id for the token.754	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {755		Self::token_owner(&self, token_id.try_into()?)756			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))757			.ok_or(Error::Revert("key too large".into()))758	}759760	/// Returns the token properties.761	///762	/// @param tokenId Id for the token.763	/// @param keys Properties keys. Empty keys for all propertyes.764	/// @return Vector of properties key/value pairs.765	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {766		let keys = keys767			.into_iter()768			.map(|key| {769				<Vec<u8>>::from(key)770					.try_into()771					.map_err(|_| Error::Revert("key too large".into()))772			})773			.collect::<Result<Vec<_>>>()?;774775		<Self as CommonCollectionOperations<T>>::token_properties(776			&self,777			token_id.try_into()?,778			if keys.is_empty() { None } else { Some(keys) },779		)780		.into_iter()781		.map(|p| {782			let key = string::from_utf8(p.key.to_vec())783				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;784			let value = bytes(p.value.to_vec());785			Ok(PropertyStruct { key, value })786		})787		.collect::<Result<Vec<_>>>()788	}789	/// @notice Transfer ownership of an RFT790	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`791	///  is the zero address. Throws if `tokenId` is not a valid RFT.792	///  Throws if RFT pieces have multiple owners.793	/// @param to The new owner794	/// @param tokenId The RFT to transfer795	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]796	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {797		let caller = T::CrossAccountId::from_eth(caller);798		let to = T::CrossAccountId::from_eth(to);799		let token = token_id.try_into()?;800		let budget = self801			.recorder802			.weight_calls_budget(<StructureWeight<T>>::find_parent());803804		let balance = balance(self, token, &caller)?;805		ensure_single_owner(self, token, balance)?;806807		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)808			.map_err(dispatch_to_evm::<T>)?;809		Ok(())810	}811812	/// @notice Transfer ownership of an RFT813	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`814	///  is the zero address. Throws if `tokenId` is not a valid RFT.815	///  Throws if RFT pieces have multiple owners.816	/// @param to The new owner817	/// @param tokenId The RFT to transfer818	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]819	fn transfer_cross(820		&mut self,821		caller: caller,822		to: EthCrossAccount,823		token_id: uint256,824	) -> Result<void> {825		let caller = T::CrossAccountId::from_eth(caller);826		let to = to.into_sub_cross_account::<T>()?;827		let token = token_id.try_into()?;828		let budget = self829			.recorder830			.weight_calls_budget(<StructureWeight<T>>::find_parent());831832		let balance = balance(self, token, &caller)?;833		ensure_single_owner(self, token, balance)?;834835		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)836			.map_err(dispatch_to_evm::<T>)?;837		Ok(())838	}839840	/// @notice Transfer ownership of an RFT841	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`842	///  is the zero address. Throws if `tokenId` is not a valid RFT.843	///  Throws if RFT pieces have multiple owners.844	/// @param to The new owner845	/// @param tokenId The RFT to transfer846	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]847	fn transfer_from_cross(848		&mut self,849		caller: caller,850		from: EthCrossAccount,851		to: EthCrossAccount,852		token_id: uint256,853	) -> Result<void> {854		let caller = T::CrossAccountId::from_eth(caller);855		let from = from.into_sub_cross_account::<T>()?;856		let to = to.into_sub_cross_account::<T>()?;857		let token_id = token_id.try_into()?;858		let budget = self859			.recorder860			.weight_calls_budget(<StructureWeight<T>>::find_parent());861862		let balance = balance(self, token_id, &from)?;863		ensure_single_owner(self, token_id, balance)?;864865		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)866			.map_err(dispatch_to_evm::<T>)?;867		Ok(())868	}869870	/// @notice Burns a specific ERC721 token.871	/// @dev Throws unless `msg.sender` is the current owner or an authorized872	///  operator for this RFT. Throws if `from` is not the current owner. Throws873	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.874	///  Throws if RFT pieces have multiple owners.875	/// @param from The current owner of the RFT876	/// @param tokenId The RFT to transfer877	#[solidity(hide)]878	#[weight(<SelfWeightOf<T>>::burn_from())]879	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {880		let caller = T::CrossAccountId::from_eth(caller);881		let from = T::CrossAccountId::from_eth(from);882		let token = token_id.try_into()?;883		let budget = self884			.recorder885			.weight_calls_budget(<StructureWeight<T>>::find_parent());886887		let balance = balance(self, token, &from)?;888		ensure_single_owner(self, token, balance)?;889890		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)891			.map_err(dispatch_to_evm::<T>)?;892		Ok(())893	}894895	/// @notice Burns a specific ERC721 token.896	/// @dev Throws unless `msg.sender` is the current owner or an authorized897	///  operator for this RFT. Throws if `from` is not the current owner. Throws898	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.899	///  Throws if RFT pieces have multiple owners.900	/// @param from The current owner of the RFT901	/// @param tokenId The RFT to transfer902	#[weight(<SelfWeightOf<T>>::burn_from())]903	fn burn_from_cross(904		&mut self,905		caller: caller,906		from: EthCrossAccount,907		token_id: uint256,908	) -> Result<void> {909		let caller = T::CrossAccountId::from_eth(caller);910		let from = from.into_sub_cross_account::<T>()?;911		let token = token_id.try_into()?;912		let budget = self913			.recorder914			.weight_calls_budget(<StructureWeight<T>>::find_parent());915916		let balance = balance(self, token, &from)?;917		ensure_single_owner(self, token, balance)?;918919		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)920			.map_err(dispatch_to_evm::<T>)?;921		Ok(())922	}923924	/// @notice Returns next free RFT ID.925	fn next_token_id(&self) -> Result<uint256> {926		self.consume_store_reads(1)?;927		Ok(<TokensMinted<T>>::get(self.id)928			.checked_add(1)929			.ok_or("item id overflow")?930			.into())931	}932933	/// @notice Function to mint multiple tokens.934	/// @dev `tokenIds` should be an array of consecutive numbers and first number935	///  should be obtained with `nextTokenId` method936	/// @param to The new owner937	/// @param tokenIds IDs of the minted RFTs938	#[solidity(hide)]939	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]940	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {941		let caller = T::CrossAccountId::from_eth(caller);942		let to = T::CrossAccountId::from_eth(to);943		let mut expected_index = <TokensMinted<T>>::get(self.id)944			.checked_add(1)945			.ok_or("item id overflow")?;946		let budget = self947			.recorder948			.weight_calls_budget(<StructureWeight<T>>::find_parent());949950		let total_tokens = token_ids.len();951		for id in token_ids.into_iter() {952			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;953			if id != expected_index {954				return Err("item id should be next".into());955			}956			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;957		}958		let users = [(to.clone(), 1)]959			.into_iter()960			.collect::<BTreeMap<_, _>>()961			.try_into()962			.unwrap();963		let create_item_data = CreateItemData::<T::CrossAccountId> {964			users,965			properties: CollectionPropertiesVec::default(),966		};967		let data = (0..total_tokens)968			.map(|_| create_item_data.clone())969			.collect();970971		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)972			.map_err(dispatch_to_evm::<T>)?;973		Ok(true)974	}975976	/// @notice Function to mint multiple tokens with the given tokenUris.977	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive978	///  numbers and first number should be obtained with `nextTokenId` method979	/// @param to The new owner980	/// @param tokens array of pairs of token ID and token URI for minted tokens981	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]982	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]983	fn mint_bulk_with_token_uri(984		&mut self,985		caller: caller,986		to: address,987		tokens: Vec<(uint256, string)>,988	) -> Result<bool> {989		let key = key::url();990		let caller = T::CrossAccountId::from_eth(caller);991		let to = T::CrossAccountId::from_eth(to);992		let mut expected_index = <TokensMinted<T>>::get(self.id)993			.checked_add(1)994			.ok_or("item id overflow")?;995		let budget = self996			.recorder997			.weight_calls_budget(<StructureWeight<T>>::find_parent());998999		let mut data = Vec::with_capacity(tokens.len());1000		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1001			.into_iter()1002			.collect::<BTreeMap<_, _>>()1003			.try_into()1004			.unwrap();1005		for (id, token_uri) in tokens {1006			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1007			if id != expected_index {1008				return Err("item id should be next".into());1009			}1010			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10111012			let mut properties = CollectionPropertiesVec::default();1013			properties1014				.try_push(Property {1015					key: key.clone(),1016					value: token_uri1017						.into_bytes()1018						.try_into()1019						.map_err(|_| "token uri is too long")?,1020				})1021				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10221023			let create_item_data = CreateItemData::<T::CrossAccountId> {1024				users: users.clone(),1025				properties,1026			};1027			data.push(create_item_data);1028		}10291030		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1031			.map_err(dispatch_to_evm::<T>)?;1032		Ok(true)1033	}10341035	/// Returns EVM address for refungible token1036	///1037	/// @param token ID of the token1038	fn token_contract_address(&self, token: uint256) -> Result<address> {1039		Ok(T::EvmTokenAddressMapping::token_to_address(1040			self.id,1041			token.try_into().map_err(|_| "token id overflow")?,1042		))1043	}1044}10451046#[solidity_interface(1047	name = UniqueRefungible,1048	is(1049		ERC721,1050		ERC721Enumerable,1051		ERC721UniqueExtensions,1052		ERC721UniqueMintable,1053		ERC721Burnable,1054		ERC721Metadata(if(this.flags.erc721metadata)),1055		Collection(via(common_mut returns CollectionHandle<T>)),1056		TokenProperties,1057	)1058)]1059impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10601061// Not a tests, but code generators1062generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1063generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);10641065impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1066where1067	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1068{1069	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1070	fn call(1071		self,1072		handle: &mut impl PrecompileHandle,1073	) -> Option<pallet_common::erc::PrecompileResult> {1074		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1075	}1076}