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

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	weight,31};32use frame_support::{BoundedBTreeMap, BoundedVec};33use pallet_common::{34	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,35	erc::{CommonEvmHandler, CollectionCall, static_property::key},36	Error as CommonError,37};38use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm_coder_substrate::{call, dispatch_to_evm};40use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};41use sp_core::{H160, Get};42use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};43use up_data_structs::{44	CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,45	PropertyKeyPermission, PropertyPermission, TokenId,46};4748use crate::{49	AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,50	TokenProperties, TokensMinted, TotalSupply, weights::WeightInfo,51};5253pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);5455/// @title A contract that allows to set and delete token properties and change token property permissions.56#[solidity_interface(name = TokenProperties)]57impl<T: Config> RefungibleHandle<T> {58	/// @notice Set permissions for token property.59	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.60	/// @param key Property key.61	/// @param isMutable Permission to mutate property.62	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.63	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.64	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]65	#[solidity(hide)]66	fn set_token_property_permission(67		&mut self,68		caller: caller,69		key: string,70		is_mutable: bool,71		collection_admin: bool,72		token_owner: bool,73	) -> Result<()> {74		let caller = T::CrossAccountId::from_eth(caller);75		<Pallet<T>>::set_token_property_permissions(76			self,77			&caller,78			vec![PropertyKeyPermission {79				key: <Vec<u8>>::from(key)80					.try_into()81					.map_err(|_| "too long key")?,82				permission: PropertyPermission {83					mutable: is_mutable,84					collection_admin,85					token_owner,86				},87			}],88		)89		.map_err(dispatch_to_evm::<T>)90	}9192	/// @notice Set permissions for token property.93	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.94	/// @param permissions Permissions for keys.95	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]96	fn set_token_property_permissions(97		&mut self,98		caller: caller,99		permissions: Vec<pallet_common::eth::TokenPropertyPermission>,100	) -> Result<()> {101		let caller = T::CrossAccountId::from_eth(caller);102		let perms = pallet_common::eth::TokenPropertyPermission::into_property_key_permissions(103			permissions,104		)?;105106		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)107			.map_err(dispatch_to_evm::<T>)108	}109110	/// @notice Get permissions for token properties.111	fn token_property_permissions(112		&self,113	) -> Result<Vec<pallet_common::eth::TokenPropertyPermission>> {114		let perms = <Pallet<T>>::token_property_permission(self.id);115		Ok(perms116			.into_iter()117			.map(pallet_common::eth::TokenPropertyPermission::from)118			.collect())119	}120121	/// @notice Set token property value.122	/// @dev Throws error if `msg.sender` has no permission to edit the property.123	/// @param tokenId ID of the token.124	/// @param key Property key.125	/// @param value Property value.126	#[solidity(hide)]127	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]128	fn set_property(129		&mut self,130		caller: caller,131		token_id: uint256,132		key: string,133		value: bytes,134	) -> Result<()> {135		let caller = T::CrossAccountId::from_eth(caller);136		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;137		let key = <Vec<u8>>::from(key)138			.try_into()139			.map_err(|_| "key too long")?;140		let value = value.0.try_into().map_err(|_| "value too long")?;141142		let nesting_budget = self143			.recorder144			.weight_calls_budget(<StructureWeight<T>>::find_parent());145146		<Pallet<T>>::set_token_property(147			self,148			&caller,149			TokenId(token_id),150			Property { key, value },151			&nesting_budget,152		)153		.map_err(dispatch_to_evm::<T>)154	}155156	/// @notice Set token properties value.157	/// @dev Throws error if `msg.sender` has no permission to edit the property.158	/// @param tokenId ID of the token.159	/// @param properties settable properties160	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]161	fn set_properties(162		&mut self,163		caller: caller,164		token_id: uint256,165		properties: Vec<pallet_common::eth::Property>,166	) -> Result<()> {167		let caller = T::CrossAccountId::from_eth(caller);168		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;169170		let nesting_budget = self171			.recorder172			.weight_calls_budget(<StructureWeight<T>>::find_parent());173174		let properties = properties175			.into_iter()176			.map(|property| {177				let (key, value) = property.take_key_value();178				let key = <Vec<u8>>::from(key)179					.try_into()180					.map_err(|_| "key too large")?;181182				let value = value.0.try_into().map_err(|_| "value too large")?;183184				Ok(Property { key, value })185			})186			.collect::<Result<Vec<_>>>()?;187188		<Pallet<T>>::set_token_properties(189			self,190			&caller,191			TokenId(token_id),192			properties.into_iter(),193			false,194			&nesting_budget,195		)196		.map_err(dispatch_to_evm::<T>)197	}198199	/// @notice Delete token property value.200	/// @dev Throws error if `msg.sender` has no permission to edit the property.201	/// @param tokenId ID of the token.202	/// @param key Property key.203	#[solidity(hide)]204	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]205	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {206		let caller = T::CrossAccountId::from_eth(caller);207		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;208		let key = <Vec<u8>>::from(key)209			.try_into()210			.map_err(|_| "key too long")?;211212		let nesting_budget = self213			.recorder214			.weight_calls_budget(<StructureWeight<T>>::find_parent());215216		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)217			.map_err(dispatch_to_evm::<T>)218	}219220	/// @notice Delete token properties value.221	/// @dev Throws error if `msg.sender` has no permission to edit the property.222	/// @param tokenId ID of the token.223	/// @param keys Properties key.224	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]225	fn delete_properties(226		&mut self,227		token_id: uint256,228		caller: caller,229		keys: Vec<string>,230	) -> Result<()> {231		let caller = T::CrossAccountId::from_eth(caller);232		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;233		let keys = keys234			.into_iter()235			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))236			.collect::<Result<Vec<_>>>()?;237238		let nesting_budget = self239			.recorder240			.weight_calls_budget(<StructureWeight<T>>::find_parent());241242		<Pallet<T>>::delete_token_properties(243			self,244			&caller,245			TokenId(token_id),246			keys.into_iter(),247			&nesting_budget,248		)249		.map_err(dispatch_to_evm::<T>)250	}251252	/// @notice Get token property value.253	/// @dev Throws error if key not found254	/// @param tokenId ID of the token.255	/// @param key Property key.256	/// @return Property value bytes257	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {258		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;259		let key = <Vec<u8>>::from(key)260			.try_into()261			.map_err(|_| "key too long")?;262263		let props = <TokenProperties<T>>::get((self.id, token_id));264		let prop = props.get(&key).ok_or("key not found")?;265266		Ok(prop.to_vec().into())267	}268}269270#[derive(ToLog)]271pub enum ERC721Events {272	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed273	///  (`to` == 0). Exception: during contract creation, any number of RFTs274	///  may be created and assigned without emitting Transfer.275	Transfer {276		#[indexed]277		from: address,278		#[indexed]279		to: address,280		#[indexed]281		token_id: uint256,282	},283	/// @dev Not supported284	Approval {285		#[indexed]286		owner: address,287		#[indexed]288		approved: address,289		#[indexed]290		token_id: uint256,291	},292	/// @dev Not supported293	#[allow(dead_code)]294	ApprovalForAll {295		#[indexed]296		owner: address,297		#[indexed]298		operator: address,299		approved: bool,300	},301}302303#[derive(ToLog)]304pub enum ERC721UniqueMintableEvents {305	/// @dev Not supported306	#[allow(dead_code)]307	MintingFinished {},308}309310#[solidity_interface(name = ERC721Metadata)]311impl<T: Config> RefungibleHandle<T>312where313	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,314{315	/// @notice A descriptive name for a collection of NFTs in this contract316	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`317	#[solidity(hide, rename_selector = "name")]318	fn name_proxy(&self) -> Result<string> {319		self.name()320	}321322	/// @notice An abbreviated name for NFTs in this contract323	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`324	#[solidity(hide, rename_selector = "symbol")]325	fn symbol_proxy(&self) -> Result<string> {326		self.symbol()327	}328329	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.330	///331	/// @dev If the token has a `url` property and it is not empty, it is returned.332	///  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`.333	///  If the collection property `baseURI` is empty or absent, return "" (empty string)334	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix335	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).336	///337	/// @return token's const_metadata338	#[solidity(rename_selector = "tokenURI")]339	fn token_uri(&self, token_id: uint256) -> Result<string> {340		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;341342		match get_token_property(self, token_id_u32, &key::url()).as_deref() {343			Err(_) | Ok("") => (),344			Ok(url) => {345				return Ok(url.into());346			}347		};348349		let base_uri =350			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())351				.map(BoundedVec::into_inner)352				.map(string::from_utf8)353				.transpose()354				.map_err(|e| {355					Error::Revert(alloc::format!(356						"Can not convert value \"baseURI\" to string with error \"{}\"",357						e358					))359				})?;360361		let base_uri = match base_uri.as_deref() {362			None | Some("") => {363				return Ok("".into());364			}365			Some(base_uri) => base_uri.into(),366		};367368		Ok(369			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {370				Err(_) | Ok("") => base_uri,371				Ok(suffix) => base_uri + suffix,372			},373		)374	}375}376377/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension378/// @dev See https://eips.ethereum.org/EIPS/eip-721379#[solidity_interface(name = ERC721Enumerable)]380impl<T: Config> RefungibleHandle<T> {381	/// @notice Enumerate valid RFTs382	/// @param index A counter less than `totalSupply()`383	/// @return The token identifier for the `index`th NFT,384	///  (sort order not specified)385	fn token_by_index(&self, index: uint256) -> Result<uint256> {386		Ok(index)387	}388389	/// Not implemented390	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {391		// TODO: Not implemetable392		Err("not implemented".into())393	}394395	/// @notice Count RFTs tracked by this contract396	/// @return A count of valid RFTs tracked by this contract, where each one of397	///  them has an assigned and queryable owner not equal to the zero address398	fn total_supply(&self) -> Result<uint256> {399		self.consume_store_reads(1)?;400		Ok(<Pallet<T>>::total_supply(self).into())401	}402}403404/// @title ERC-721 Non-Fungible Token Standard405/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md406#[solidity_interface(name = ERC721, events(ERC721Events))]407impl<T: Config> RefungibleHandle<T> {408	/// @notice Count all RFTs assigned to an owner409	/// @dev RFTs assigned to the zero address are considered invalid, and this410	///  function throws for queries about the zero address.411	/// @param owner An address for whom to query the balance412	/// @return The number of RFTs owned by `owner`, possibly zero413	fn balance_of(&self, owner: address) -> Result<uint256> {414		self.consume_store_reads(1)?;415		let owner = T::CrossAccountId::from_eth(owner);416		let balance = <AccountBalance<T>>::get((self.id, owner));417		Ok(balance.into())418	}419420	/// @notice Find the owner of an RFT421	/// @dev RFTs assigned to zero address are considered invalid, and queries422	///  about them do throw.423	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for424	///  the tokens that are partially owned.425	/// @param tokenId The identifier for an RFT426	/// @return The address of the owner of the RFT427	fn owner_of(&self, token_id: uint256) -> Result<address> {428		self.consume_store_reads(2)?;429		let token = token_id.try_into()?;430		let owner = <Pallet<T>>::token_owner(self.id, token);431		Ok(owner432			.map(|address| *address.as_eth())433			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))434	}435436	/// @dev Not implemented437	fn safe_transfer_from_with_data(438		&mut self,439		_from: address,440		_to: address,441		_token_id: uint256,442		_data: bytes,443	) -> Result<void> {444		// TODO: Not implemetable445		Err("not implemented".into())446	}447448	/// @dev Not implemented449	fn safe_transfer_from(450		&mut self,451		_from: address,452		_to: address,453		_token_id: uint256,454	) -> Result<void> {455		// TODO: Not implemetable456		Err("not implemented".into())457	}458459	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE460	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE461	///  THEY MAY BE PERMANENTLY LOST462	/// @dev Throws unless `msg.sender` is the current owner or an authorized463	///  operator for this RFT. Throws if `from` is not the current owner. Throws464	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.465	///  Throws if RFT pieces have multiple owners.466	/// @param from The current owner of the NFT467	/// @param to The new owner468	/// @param tokenId The NFT to transfer469	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]470	fn transfer_from(471		&mut self,472		caller: caller,473		from: address,474		to: address,475		token_id: uint256,476	) -> Result<void> {477		let caller = T::CrossAccountId::from_eth(caller);478		let from = T::CrossAccountId::from_eth(from);479		let to = T::CrossAccountId::from_eth(to);480		let token = token_id.try_into()?;481		let budget = self482			.recorder483			.weight_calls_budget(<StructureWeight<T>>::find_parent());484485		let balance = balance(&self, token, &from)?;486		ensure_single_owner(&self, token, balance)?;487488		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)489			.map_err(dispatch_to_evm::<T>)?;490491		Ok(())492	}493494	/// @dev Not implemented495	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {496		Err("not implemented".into())497	}498499	/// @notice Sets or unsets the approval of a given operator.500	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.501	/// @param operator Operator502	/// @param approved Should operator status be granted or revoked?503	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]504	fn set_approval_for_all(505		&mut self,506		caller: caller,507		operator: address,508		approved: bool,509	) -> Result<void> {510		let caller = T::CrossAccountId::from_eth(caller);511		let operator = T::CrossAccountId::from_eth(operator);512513		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)514			.map_err(dispatch_to_evm::<T>)?;515		Ok(())516	}517518	/// @dev Not implemented519	fn get_approved(&self, _token_id: uint256) -> Result<address> {520		// TODO: Not implemetable521		Err("not implemented".into())522	}523524	/// @notice Tells whether the given `owner` approves the `operator`.525	#[weight(<SelfWeightOf<T>>::allowance_for_all())]526	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {527		let owner = T::CrossAccountId::from_eth(owner);528		let operator = T::CrossAccountId::from_eth(operator);529530		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))531	}532533	/// @notice Returns collection helper contract address534	fn collection_helper_address(&self) -> Result<address> {535		Ok(T::ContractAddress::get())536	}537}538539/// Returns amount of pieces of `token` that `owner` have540pub fn balance<T: Config>(541	collection: &RefungibleHandle<T>,542	token: TokenId,543	owner: &T::CrossAccountId,544) -> Result<u128> {545	collection.consume_store_reads(1)?;546	let balance = <Balance<T>>::get((collection.id, token, &owner));547	Ok(balance)548}549550/// Throws if `owner_balance` is lower than total amount of `token` pieces551pub fn ensure_single_owner<T: Config>(552	collection: &RefungibleHandle<T>,553	token: TokenId,554	owner_balance: u128,555) -> Result<()> {556	collection.consume_store_reads(1)?;557	let total_supply = <TotalSupply<T>>::get((collection.id, token));558559	if owner_balance == 0 {560		return Err(dispatch_to_evm::<T>(561			<CommonError<T>>::MustBeTokenOwner.into(),562		));563	}564565	if total_supply != owner_balance {566		return Err("token has multiple owners".into());567	}568	Ok(())569}570571/// @title ERC721 Token that can be irreversibly burned (destroyed).572#[solidity_interface(name = ERC721Burnable)]573impl<T: Config> RefungibleHandle<T> {574	/// @notice Burns a specific ERC721 token.575	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized576	///  operator of the current owner.577	/// @param tokenId The RFT to approve578	#[weight(<SelfWeightOf<T>>::burn_item_fully())]579	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {580		let caller = T::CrossAccountId::from_eth(caller);581		let token = token_id.try_into()?;582583		let balance = balance(&self, token, &caller)?;584		ensure_single_owner(&self, token, balance)?;585586		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;587		Ok(())588	}589}590591/// @title ERC721 minting logic.592#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]593impl<T: Config> RefungibleHandle<T> {594	fn minting_finished(&self) -> Result<bool> {595		Ok(false)596	}597598	/// @notice Function to mint a token.599	/// @param to The new owner600	/// @return uint256 The id of the newly minted token601	#[weight(<SelfWeightOf<T>>::create_item())]602	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {603		let token_id: uint256 = <TokensMinted<T>>::get(self.id)604			.checked_add(1)605			.ok_or("item id overflow")?606			.into();607		self.mint_check_id(caller, to, token_id)?;608		Ok(token_id)609	}610611	/// @notice Function to mint a token.612	/// @dev `tokenId` should be obtained with `nextTokenId` method,613	///  unlike standard, you can't specify it manually614	/// @param to The new owner615	/// @param tokenId ID of the minted RFT616	#[solidity(hide, rename_selector = "mint")]617	#[weight(<SelfWeightOf<T>>::create_item())]618	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {619		let caller = T::CrossAccountId::from_eth(caller);620		let to = T::CrossAccountId::from_eth(to);621		let token_id: u32 = token_id.try_into()?;622		let budget = self623			.recorder624			.weight_calls_budget(<StructureWeight<T>>::find_parent());625626		if <TokensMinted<T>>::get(self.id)627			.checked_add(1)628			.ok_or("item id overflow")?629			!= token_id630		{631			return Err("item id should be next".into());632		}633634		let users = [(to.clone(), 1)]635			.into_iter()636			.collect::<BTreeMap<_, _>>()637			.try_into()638			.unwrap();639		<Pallet<T>>::create_item(640			self,641			&caller,642			CreateItemData::<T> {643				users,644				properties: CollectionPropertiesVec::default(),645			},646			&budget,647		)648		.map_err(dispatch_to_evm::<T>)?;649650		Ok(true)651	}652653	/// @notice Function to mint token with the given tokenUri.654	/// @param to The new owner655	/// @param tokenUri Token URI that would be stored in the NFT properties656	/// @return uint256 The id of the newly minted token657	#[solidity(rename_selector = "mintWithTokenURI")]658	#[weight(<SelfWeightOf<T>>::create_item())]659	fn mint_with_token_uri(660		&mut self,661		caller: caller,662		to: address,663		token_uri: string,664	) -> Result<uint256> {665		let token_id: uint256 = <TokensMinted<T>>::get(self.id)666			.checked_add(1)667			.ok_or("item id overflow")?668			.into();669		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;670		Ok(token_id)671	}672673	/// @notice Function to mint token with the given tokenUri.674	/// @dev `tokenId` should be obtained with `nextTokenId` method,675	///  unlike standard, you can't specify it manually676	/// @param to The new owner677	/// @param tokenId ID of the minted RFT678	/// @param tokenUri Token URI that would be stored in the RFT properties679	#[solidity(hide, rename_selector = "mintWithTokenURI")]680	#[weight(<SelfWeightOf<T>>::create_item())]681	fn mint_with_token_uri_check_id(682		&mut self,683		caller: caller,684		to: address,685		token_id: uint256,686		token_uri: string,687	) -> Result<bool> {688		let key = key::url();689		let permission = get_token_permission::<T>(self.id, &key)?;690		if !permission.collection_admin {691			return Err("Operation is not allowed".into());692		}693694		let caller = T::CrossAccountId::from_eth(caller);695		let to = T::CrossAccountId::from_eth(to);696		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;697		let budget = self698			.recorder699			.weight_calls_budget(<StructureWeight<T>>::find_parent());700701		if <TokensMinted<T>>::get(self.id)702			.checked_add(1)703			.ok_or("item id overflow")?704			!= token_id705		{706			return Err("item id should be next".into());707		}708709		let mut properties = CollectionPropertiesVec::default();710		properties711			.try_push(Property {712				key,713				value: token_uri714					.into_bytes()715					.try_into()716					.map_err(|_| "token uri is too long")?,717			})718			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;719720		let users = [(to.clone(), 1)]721			.into_iter()722			.collect::<BTreeMap<_, _>>()723			.try_into()724			.unwrap();725		<Pallet<T>>::create_item(726			self,727			&caller,728			CreateItemData::<T> { users, properties },729			&budget,730		)731		.map_err(dispatch_to_evm::<T>)?;732		Ok(true)733	}734735	/// @dev Not implemented736	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {737		Err("not implementable".into())738	}739}740741fn get_token_property<T: Config>(742	collection: &CollectionHandle<T>,743	token_id: u32,744	key: &up_data_structs::PropertyKey,745) -> Result<string> {746	collection.consume_store_reads(1)?;747	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))748		.map_err(|_| Error::Revert("Token properties not found".into()))?;749	if let Some(property) = properties.get(key) {750		return Ok(string::from_utf8_lossy(property).into());751	}752753	Err("Property tokenURI not found".into())754}755756fn get_token_permission<T: Config>(757	collection_id: CollectionId,758	key: &PropertyKey,759) -> Result<PropertyPermission> {760	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)761		.map_err(|_| Error::Revert("No permissions for collection".into()))?;762	let a = token_property_permissions763		.get(key)764		.map(Clone::clone)765		.ok_or_else(|| {766			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();767			Error::Revert(alloc::format!("No permission for key {}", key))768		})?;769	Ok(a)770}771772/// @title Unique extensions for ERC721.773#[solidity_interface(name = ERC721UniqueExtensions)]774impl<T: Config> RefungibleHandle<T>775where776	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,777{778	/// @notice A descriptive name for a collection of NFTs in this contract779	fn name(&self) -> Result<string> {780		Ok(decode_utf16(self.name.iter().copied())781			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))782			.collect::<string>())783	}784785	/// @notice An abbreviated name for NFTs in this contract786	fn symbol(&self) -> Result<string> {787		Ok(string::from_utf8_lossy(&self.token_prefix).into())788	}789790	/// @notice A description for the collection.791	fn description(&self) -> Result<string> {792		Ok(decode_utf16(self.description.iter().copied())793			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))794			.collect::<string>())795	}796797	/// Returns the owner (in cross format) of the token.798	///799	/// @param tokenId Id for the token.800	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {801		Self::token_owner(&self, token_id.try_into()?)802			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))803			.ok_or(Error::Revert("key too large".into()))804	}805806	/// Returns the token properties.807	///808	/// @param tokenId Id for the token.809	/// @param keys Properties keys. Empty keys for all propertyes.810	/// @return Vector of properties key/value pairs.811	fn properties(812		&self,813		token_id: uint256,814		keys: Vec<string>,815	) -> Result<Vec<pallet_common::eth::Property>> {816		let keys = keys817			.into_iter()818			.map(|key| {819				<Vec<u8>>::from(key)820					.try_into()821					.map_err(|_| Error::Revert("key too large".into()))822			})823			.collect::<Result<Vec<_>>>()?;824825		<Self as CommonCollectionOperations<T>>::token_properties(826			&self,827			token_id.try_into()?,828			if keys.is_empty() { None } else { Some(keys) },829		)830		.into_iter()831		.map(|p| {832			let key = string::from_utf8(p.key.to_vec())833				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;834			let value = bytes(p.value.to_vec());835			Ok(pallet_common::eth::Property::new(key, value))836		})837		.collect::<Result<Vec<_>>>()838	}839	/// @notice Transfer ownership of an RFT840	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`841	///  is the zero address. Throws if `tokenId` is not a valid RFT.842	///  Throws if RFT pieces have multiple owners.843	/// @param to The new owner844	/// @param tokenId The RFT to transfer845	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]846	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {847		let caller = T::CrossAccountId::from_eth(caller);848		let to = T::CrossAccountId::from_eth(to);849		let token = token_id.try_into()?;850		let budget = self851			.recorder852			.weight_calls_budget(<StructureWeight<T>>::find_parent());853854		let balance = balance(self, token, &caller)?;855		ensure_single_owner(self, token, balance)?;856857		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)858			.map_err(dispatch_to_evm::<T>)?;859		Ok(())860	}861862	/// @notice Transfer ownership of an RFT863	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`864	///  is the zero address. Throws if `tokenId` is not a valid RFT.865	///  Throws if RFT pieces have multiple owners.866	/// @param to The new owner867	/// @param tokenId The RFT to transfer868	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]869	fn transfer_cross(870		&mut self,871		caller: caller,872		to: pallet_common::eth::CrossAddress,873		token_id: uint256,874	) -> Result<void> {875		let caller = T::CrossAccountId::from_eth(caller);876		let to = to.into_sub_cross_account::<T>()?;877		let token = token_id.try_into()?;878		let budget = self879			.recorder880			.weight_calls_budget(<StructureWeight<T>>::find_parent());881882		let balance = balance(self, token, &caller)?;883		ensure_single_owner(self, token, balance)?;884885		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)886			.map_err(dispatch_to_evm::<T>)?;887		Ok(())888	}889890	/// @notice Transfer ownership of an RFT891	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`892	///  is the zero address. Throws if `tokenId` is not a valid RFT.893	///  Throws if RFT pieces have multiple owners.894	/// @param to The new owner895	/// @param tokenId The RFT to transfer896	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]897	fn transfer_from_cross(898		&mut self,899		caller: caller,900		from: pallet_common::eth::CrossAddress,901		to: pallet_common::eth::CrossAddress,902		token_id: uint256,903	) -> Result<void> {904		let caller = T::CrossAccountId::from_eth(caller);905		let from = from.into_sub_cross_account::<T>()?;906		let to = to.into_sub_cross_account::<T>()?;907		let token_id = token_id.try_into()?;908		let budget = self909			.recorder910			.weight_calls_budget(<StructureWeight<T>>::find_parent());911912		let balance = balance(self, token_id, &from)?;913		ensure_single_owner(self, token_id, balance)?;914915		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)916			.map_err(dispatch_to_evm::<T>)?;917		Ok(())918	}919920	/// @notice Burns a specific ERC721 token.921	/// @dev Throws unless `msg.sender` is the current owner or an authorized922	///  operator for this RFT. Throws if `from` is not the current owner. Throws923	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.924	///  Throws if RFT pieces have multiple owners.925	/// @param from The current owner of the RFT926	/// @param tokenId The RFT to transfer927	#[solidity(hide)]928	#[weight(<SelfWeightOf<T>>::burn_from())]929	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {930		let caller = T::CrossAccountId::from_eth(caller);931		let from = T::CrossAccountId::from_eth(from);932		let token = token_id.try_into()?;933		let budget = self934			.recorder935			.weight_calls_budget(<StructureWeight<T>>::find_parent());936937		let balance = balance(self, token, &from)?;938		ensure_single_owner(self, token, balance)?;939940		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)941			.map_err(dispatch_to_evm::<T>)?;942		Ok(())943	}944945	/// @notice Burns a specific ERC721 token.946	/// @dev Throws unless `msg.sender` is the current owner or an authorized947	///  operator for this RFT. Throws if `from` is not the current owner. Throws948	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.949	///  Throws if RFT pieces have multiple owners.950	/// @param from The current owner of the RFT951	/// @param tokenId The RFT to transfer952	#[weight(<SelfWeightOf<T>>::burn_from())]953	fn burn_from_cross(954		&mut self,955		caller: caller,956		from: pallet_common::eth::CrossAddress,957		token_id: uint256,958	) -> Result<void> {959		let caller = T::CrossAccountId::from_eth(caller);960		let from = from.into_sub_cross_account::<T>()?;961		let token = token_id.try_into()?;962		let budget = self963			.recorder964			.weight_calls_budget(<StructureWeight<T>>::find_parent());965966		let balance = balance(self, token, &from)?;967		ensure_single_owner(self, token, balance)?;968969		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)970			.map_err(dispatch_to_evm::<T>)?;971		Ok(())972	}973974	/// @notice Returns next free RFT ID.975	fn next_token_id(&self) -> Result<uint256> {976		self.consume_store_reads(1)?;977		Ok(<TokensMinted<T>>::get(self.id)978			.checked_add(1)979			.ok_or("item id overflow")?980			.into())981	}982983	/// @notice Function to mint multiple tokens.984	/// @dev `tokenIds` should be an array of consecutive numbers and first number985	///  should be obtained with `nextTokenId` method986	/// @param to The new owner987	/// @param tokenIds IDs of the minted RFTs988	#[solidity(hide)]989	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]990	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {991		let caller = T::CrossAccountId::from_eth(caller);992		let to = T::CrossAccountId::from_eth(to);993		let mut expected_index = <TokensMinted<T>>::get(self.id)994			.checked_add(1)995			.ok_or("item id overflow")?;996		let budget = self997			.recorder998			.weight_calls_budget(<StructureWeight<T>>::find_parent());9991000		let total_tokens = token_ids.len();1001		for id in token_ids.into_iter() {1002			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1003			if id != expected_index {1004				return Err("item id should be next".into());1005			}1006			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1007		}1008		let users = [(to.clone(), 1)]1009			.into_iter()1010			.collect::<BTreeMap<_, _>>()1011			.try_into()1012			.unwrap();1013		let create_item_data = CreateItemData::<T> {1014			users,1015			properties: CollectionPropertiesVec::default(),1016		};1017		let data = (0..total_tokens)1018			.map(|_| create_item_data.clone())1019			.collect();10201021		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1022			.map_err(dispatch_to_evm::<T>)?;1023		Ok(true)1024	}10251026	/// @notice Function to mint multiple tokens with the given tokenUris.1027	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1028	///  numbers and first number should be obtained with `nextTokenId` method1029	/// @param to The new owner1030	/// @param tokens array of pairs of token ID and token URI for minted tokens1031	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1032	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1033	fn mint_bulk_with_token_uri(1034		&mut self,1035		caller: caller,1036		to: address,1037		tokens: Vec<(uint256, string)>,1038	) -> Result<bool> {1039		let key = key::url();1040		let caller = T::CrossAccountId::from_eth(caller);1041		let to = T::CrossAccountId::from_eth(to);1042		let mut expected_index = <TokensMinted<T>>::get(self.id)1043			.checked_add(1)1044			.ok_or("item id overflow")?;1045		let budget = self1046			.recorder1047			.weight_calls_budget(<StructureWeight<T>>::find_parent());10481049		let mut data = Vec::with_capacity(tokens.len());1050		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1051			.into_iter()1052			.collect::<BTreeMap<_, _>>()1053			.try_into()1054			.unwrap();1055		for (id, token_uri) in tokens {1056			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1057			if id != expected_index {1058				return Err("item id should be next".into());1059			}1060			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10611062			let mut properties = CollectionPropertiesVec::default();1063			properties1064				.try_push(Property {1065					key: key.clone(),1066					value: token_uri1067						.into_bytes()1068						.try_into()1069						.map_err(|_| "token uri is too long")?,1070				})1071				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10721073			let create_item_data = CreateItemData::<T> {1074				users: users.clone(),1075				properties,1076			};1077			data.push(create_item_data);1078		}10791080		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1081			.map_err(dispatch_to_evm::<T>)?;1082		Ok(true)1083	}10841085	/// @notice Function to mint a token.1086	/// @param to The new owner crossAccountId1087	/// @param properties Properties of minted token1088	/// @return uint256 The id of the newly minted token1089	#[weight(<SelfWeightOf<T>>::create_item())]1090	fn mint_cross(1091		&mut self,1092		caller: caller,1093		to: pallet_common::eth::CrossAddress,1094		properties: Vec<pallet_common::eth::Property>,1095	) -> Result<uint256> {1096		let token_id = <TokensMinted<T>>::get(self.id)1097			.checked_add(1)1098			.ok_or("item id overflow")?;10991100		let to = to.into_sub_cross_account::<T>()?;11011102		let properties = properties1103			.into_iter()1104			.map(|property| {1105				let (key, value) = property.take_key_value();1106				let key = <Vec<u8>>::from(key)1107					.try_into()1108					.map_err(|_| "key too large")?;11091110				let value = value.0.try_into().map_err(|_| "value too large")?;11111112				Ok(Property { key, value })1113			})1114			.collect::<Result<Vec<_>>>()?1115			.try_into()1116			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;11171118		let caller = T::CrossAccountId::from_eth(caller);11191120		let budget = self1121			.recorder1122			.weight_calls_budget(<StructureWeight<T>>::find_parent());11231124		let users = [(to, 1)]1125			.into_iter()1126			.collect::<BTreeMap<_, _>>()1127			.try_into()1128			.unwrap();1129		<Pallet<T>>::create_item(1130			self,1131			&caller,1132			CreateItemData::<T> { users, properties },1133			&budget,1134		)1135		.map_err(dispatch_to_evm::<T>)?;11361137		Ok(token_id.into())1138	}11391140	/// Returns EVM address for refungible token1141	///1142	/// @param token ID of the token1143	fn token_contract_address(&self, token: uint256) -> Result<address> {1144		Ok(T::EvmTokenAddressMapping::token_to_address(1145			self.id,1146			token.try_into().map_err(|_| "token id overflow")?,1147		))1148	}1149}11501151#[solidity_interface(1152	name = UniqueRefungible,1153	is(1154		ERC721,1155		ERC721Enumerable,1156		ERC721UniqueExtensions,1157		ERC721UniqueMintable,1158		ERC721Burnable,1159		ERC721Metadata(if(this.flags.erc721metadata)),1160		Collection(via(common_mut returns CollectionHandle<T>)),1161		TokenProperties,1162	)1163)]1164impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11651166// Not a tests, but code generators1167generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1168generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);11691170impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1171where1172	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1173{1174	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1175	fn call(1176		self,1177		handle: &mut impl PrecompileHandle,1178	) -> Option<pallet_common::erc::PrecompileResult> {1179		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1180	}1181}