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

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(|pallet_common::eth::Property { key, value }| {177				let key = <Vec<u8>>::from(key)178					.try_into()179					.map_err(|_| "key too large")?;180181				let value = value.0.try_into().map_err(|_| "value too large")?;182183				Ok(Property { key, value })184			})185			.collect::<Result<Vec<_>>>()?;186187		<Pallet<T>>::set_token_properties(188			self,189			&caller,190			TokenId(token_id),191			properties.into_iter(),192			false,193			&nesting_budget,194		)195		.map_err(dispatch_to_evm::<T>)196	}197198	/// @notice Delete token property value.199	/// @dev Throws error if `msg.sender` has no permission to edit the property.200	/// @param tokenId ID of the token.201	/// @param key Property key.202	#[solidity(hide)]203	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]204	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {205		let caller = T::CrossAccountId::from_eth(caller);206		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;207		let key = <Vec<u8>>::from(key)208			.try_into()209			.map_err(|_| "key too long")?;210211		let nesting_budget = self212			.recorder213			.weight_calls_budget(<StructureWeight<T>>::find_parent());214215		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)216			.map_err(dispatch_to_evm::<T>)217	}218219	/// @notice Delete token properties value.220	/// @dev Throws error if `msg.sender` has no permission to edit the property.221	/// @param tokenId ID of the token.222	/// @param keys Properties key.223	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]224	fn delete_properties(225		&mut self,226		token_id: uint256,227		caller: caller,228		keys: Vec<string>,229	) -> Result<()> {230		let caller = T::CrossAccountId::from_eth(caller);231		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;232		let keys = keys233			.into_iter()234			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))235			.collect::<Result<Vec<_>>>()?;236237		let nesting_budget = self238			.recorder239			.weight_calls_budget(<StructureWeight<T>>::find_parent());240241		<Pallet<T>>::delete_token_properties(242			self,243			&caller,244			TokenId(token_id),245			keys.into_iter(),246			&nesting_budget,247		)248		.map_err(dispatch_to_evm::<T>)249	}250251	/// @notice Get token property value.252	/// @dev Throws error if key not found253	/// @param tokenId ID of the token.254	/// @param key Property key.255	/// @return Property value bytes256	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {257		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;258		let key = <Vec<u8>>::from(key)259			.try_into()260			.map_err(|_| "key too long")?;261262		let props = <TokenProperties<T>>::get((self.id, token_id));263		let prop = props.get(&key).ok_or("key not found")?;264265		Ok(prop.to_vec().into())266	}267}268269#[derive(ToLog)]270pub enum ERC721Events {271	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed272	///  (`to` == 0). Exception: during contract creation, any number of RFTs273	///  may be created and assigned without emitting Transfer.274	Transfer {275		#[indexed]276		from: address,277		#[indexed]278		to: address,279		#[indexed]280		token_id: uint256,281	},282	/// @dev Not supported283	Approval {284		#[indexed]285		owner: address,286		#[indexed]287		approved: address,288		#[indexed]289		token_id: uint256,290	},291	/// @dev Not supported292	#[allow(dead_code)]293	ApprovalForAll {294		#[indexed]295		owner: address,296		#[indexed]297		operator: address,298		approved: bool,299	},300}301302#[derive(ToLog)]303pub enum ERC721UniqueMintableEvents {304	/// @dev Not supported305	#[allow(dead_code)]306	MintingFinished {},307}308309#[solidity_interface(name = ERC721Metadata)]310impl<T: Config> RefungibleHandle<T>311where312	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,313{314	/// @notice A descriptive name for a collection of NFTs in this contract315	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`316	#[solidity(hide, rename_selector = "name")]317	fn name_proxy(&self) -> Result<string> {318		self.name()319	}320321	/// @notice An abbreviated name for NFTs in this contract322	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`323	#[solidity(hide, rename_selector = "symbol")]324	fn symbol_proxy(&self) -> Result<string> {325		self.symbol()326	}327328	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.329	///330	/// @dev If the token has a `url` property and it is not empty, it is returned.331	///  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`.332	///  If the collection property `baseURI` is empty or absent, return "" (empty string)333	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix334	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).335	///336	/// @return token's const_metadata337	#[solidity(rename_selector = "tokenURI")]338	fn token_uri(&self, token_id: uint256) -> Result<string> {339		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;340341		match get_token_property(self, token_id_u32, &key::url()).as_deref() {342			Err(_) | Ok("") => (),343			Ok(url) => {344				return Ok(url.into());345			}346		};347348		let base_uri =349			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())350				.map(BoundedVec::into_inner)351				.map(string::from_utf8)352				.transpose()353				.map_err(|e| {354					Error::Revert(alloc::format!(355						"Can not convert value \"baseURI\" to string with error \"{}\"",356						e357					))358				})?;359360		let base_uri = match base_uri.as_deref() {361			None | Some("") => {362				return Ok("".into());363			}364			Some(base_uri) => base_uri.into(),365		};366367		Ok(368			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {369				Err(_) | Ok("") => base_uri,370				Ok(suffix) => base_uri + suffix,371			},372		)373	}374}375376/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension377/// @dev See https://eips.ethereum.org/EIPS/eip-721378#[solidity_interface(name = ERC721Enumerable)]379impl<T: Config> RefungibleHandle<T> {380	/// @notice Enumerate valid RFTs381	/// @param index A counter less than `totalSupply()`382	/// @return The token identifier for the `index`th NFT,383	///  (sort order not specified)384	fn token_by_index(&self, index: uint256) -> Result<uint256> {385		Ok(index)386	}387388	/// Not implemented389	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {390		// TODO: Not implemetable391		Err("not implemented".into())392	}393394	/// @notice Count RFTs tracked by this contract395	/// @return A count of valid RFTs tracked by this contract, where each one of396	///  them has an assigned and queryable owner not equal to the zero address397	fn total_supply(&self) -> Result<uint256> {398		self.consume_store_reads(1)?;399		Ok(<Pallet<T>>::total_supply(self).into())400	}401}402403/// @title ERC-721 Non-Fungible Token Standard404/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md405#[solidity_interface(name = ERC721, events(ERC721Events))]406impl<T: Config> RefungibleHandle<T> {407	/// @notice Count all RFTs assigned to an owner408	/// @dev RFTs assigned to the zero address are considered invalid, and this409	///  function throws for queries about the zero address.410	/// @param owner An address for whom to query the balance411	/// @return The number of RFTs owned by `owner`, possibly zero412	fn balance_of(&self, owner: address) -> Result<uint256> {413		self.consume_store_reads(1)?;414		let owner = T::CrossAccountId::from_eth(owner);415		let balance = <AccountBalance<T>>::get((self.id, owner));416		Ok(balance.into())417	}418419	/// @notice Find the owner of an RFT420	/// @dev RFTs assigned to zero address are considered invalid, and queries421	///  about them do throw.422	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for423	///  the tokens that are partially owned.424	/// @param tokenId The identifier for an RFT425	/// @return The address of the owner of the RFT426	fn owner_of(&self, token_id: uint256) -> Result<address> {427		self.consume_store_reads(2)?;428		let token = token_id.try_into()?;429		let owner = <Pallet<T>>::token_owner(self.id, token);430		Ok(owner431			.map(|address| *address.as_eth())432			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))433	}434435	/// @dev Not implemented436	fn safe_transfer_from_with_data(437		&mut self,438		_from: address,439		_to: address,440		_token_id: uint256,441		_data: bytes,442	) -> Result<void> {443		// TODO: Not implemetable444		Err("not implemented".into())445	}446447	/// @dev Not implemented448	fn safe_transfer_from(449		&mut self,450		_from: address,451		_to: address,452		_token_id: uint256,453	) -> Result<void> {454		// TODO: Not implemetable455		Err("not implemented".into())456	}457458	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE459	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE460	///  THEY MAY BE PERMANENTLY LOST461	/// @dev Throws unless `msg.sender` is the current owner or an authorized462	///  operator for this RFT. Throws if `from` is not the current owner. Throws463	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.464	///  Throws if RFT pieces have multiple owners.465	/// @param from The current owner of the NFT466	/// @param to The new owner467	/// @param tokenId The NFT to transfer468	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]469	fn transfer_from(470		&mut self,471		caller: caller,472		from: address,473		to: address,474		token_id: uint256,475	) -> Result<void> {476		let caller = T::CrossAccountId::from_eth(caller);477		let from = T::CrossAccountId::from_eth(from);478		let to = T::CrossAccountId::from_eth(to);479		let token = token_id.try_into()?;480		let budget = self481			.recorder482			.weight_calls_budget(<StructureWeight<T>>::find_parent());483484		let balance = balance(&self, token, &from)?;485		ensure_single_owner(&self, token, balance)?;486487		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)488			.map_err(dispatch_to_evm::<T>)?;489490		Ok(())491	}492493	/// @dev Not implemented494	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {495		Err("not implemented".into())496	}497498	/// @notice Sets or unsets the approval of a given operator.499	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.500	/// @param operator Operator501	/// @param approved Should operator status be granted or revoked?502	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]503	fn set_approval_for_all(504		&mut self,505		caller: caller,506		operator: address,507		approved: bool,508	) -> Result<void> {509		let caller = T::CrossAccountId::from_eth(caller);510		let operator = T::CrossAccountId::from_eth(operator);511512		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)513			.map_err(dispatch_to_evm::<T>)?;514		Ok(())515	}516517	/// @dev Not implemented518	fn get_approved(&self, _token_id: uint256) -> Result<address> {519		// TODO: Not implemetable520		Err("not implemented".into())521	}522523	/// @notice Tells whether the given `owner` approves the `operator`.524	#[weight(<SelfWeightOf<T>>::allowance_for_all())]525	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {526		let owner = T::CrossAccountId::from_eth(owner);527		let operator = T::CrossAccountId::from_eth(operator);528529		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))530	}531532	/// @notice Returns collection helper contract address533	fn collection_helper_address(&self) -> Result<address> {534		Ok(T::ContractAddress::get())535	}536}537538/// Returns amount of pieces of `token` that `owner` have539pub fn balance<T: Config>(540	collection: &RefungibleHandle<T>,541	token: TokenId,542	owner: &T::CrossAccountId,543) -> Result<u128> {544	collection.consume_store_reads(1)?;545	let balance = <Balance<T>>::get((collection.id, token, &owner));546	Ok(balance)547}548549/// Throws if `owner_balance` is lower than total amount of `token` pieces550pub fn ensure_single_owner<T: Config>(551	collection: &RefungibleHandle<T>,552	token: TokenId,553	owner_balance: u128,554) -> Result<()> {555	collection.consume_store_reads(1)?;556	let total_supply = <TotalSupply<T>>::get((collection.id, token));557558	if owner_balance == 0 {559		return Err(dispatch_to_evm::<T>(560			<CommonError<T>>::MustBeTokenOwner.into(),561		));562	}563564	if total_supply != owner_balance {565		return Err("token has multiple owners".into());566	}567	Ok(())568}569570/// @title ERC721 Token that can be irreversibly burned (destroyed).571#[solidity_interface(name = ERC721Burnable)]572impl<T: Config> RefungibleHandle<T> {573	/// @notice Burns a specific ERC721 token.574	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized575	///  operator of the current owner.576	/// @param tokenId The RFT to approve577	#[weight(<SelfWeightOf<T>>::burn_item_fully())]578	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {579		let caller = T::CrossAccountId::from_eth(caller);580		let token = token_id.try_into()?;581582		let balance = balance(&self, token, &caller)?;583		ensure_single_owner(&self, token, balance)?;584585		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;586		Ok(())587	}588}589590/// @title ERC721 minting logic.591#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]592impl<T: Config> RefungibleHandle<T> {593	fn minting_finished(&self) -> Result<bool> {594		Ok(false)595	}596597	/// @notice Function to mint a token.598	/// @param to The new owner599	/// @return uint256 The id of the newly minted token600	#[weight(<SelfWeightOf<T>>::create_item())]601	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {602		let token_id: uint256 = <TokensMinted<T>>::get(self.id)603			.checked_add(1)604			.ok_or("item id overflow")?605			.into();606		self.mint_check_id(caller, to, token_id)?;607		Ok(token_id)608	}609610	/// @notice Function to mint a token.611	/// @dev `tokenId` should be obtained with `nextTokenId` method,612	///  unlike standard, you can't specify it manually613	/// @param to The new owner614	/// @param tokenId ID of the minted RFT615	#[solidity(hide, rename_selector = "mint")]616	#[weight(<SelfWeightOf<T>>::create_item())]617	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {618		let caller = T::CrossAccountId::from_eth(caller);619		let to = T::CrossAccountId::from_eth(to);620		let token_id: u32 = token_id.try_into()?;621		let budget = self622			.recorder623			.weight_calls_budget(<StructureWeight<T>>::find_parent());624625		if <TokensMinted<T>>::get(self.id)626			.checked_add(1)627			.ok_or("item id overflow")?628			!= token_id629		{630			return Err("item id should be next".into());631		}632633		let users = [(to.clone(), 1)]634			.into_iter()635			.collect::<BTreeMap<_, _>>()636			.try_into()637			.unwrap();638		<Pallet<T>>::create_item(639			self,640			&caller,641			CreateItemData::<T> {642				users,643				properties: CollectionPropertiesVec::default(),644			},645			&budget,646		)647		.map_err(dispatch_to_evm::<T>)?;648649		Ok(true)650	}651652	/// @notice Function to mint token with the given tokenUri.653	/// @param to The new owner654	/// @param tokenUri Token URI that would be stored in the NFT properties655	/// @return uint256 The id of the newly minted token656	#[solidity(rename_selector = "mintWithTokenURI")]657	#[weight(<SelfWeightOf<T>>::create_item())]658	fn mint_with_token_uri(659		&mut self,660		caller: caller,661		to: address,662		token_uri: string,663	) -> Result<uint256> {664		let token_id: uint256 = <TokensMinted<T>>::get(self.id)665			.checked_add(1)666			.ok_or("item id overflow")?667			.into();668		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;669		Ok(token_id)670	}671672	/// @notice Function to mint token with the given tokenUri.673	/// @dev `tokenId` should be obtained with `nextTokenId` method,674	///  unlike standard, you can't specify it manually675	/// @param to The new owner676	/// @param tokenId ID of the minted RFT677	/// @param tokenUri Token URI that would be stored in the RFT properties678	#[solidity(hide, rename_selector = "mintWithTokenURI")]679	#[weight(<SelfWeightOf<T>>::create_item())]680	fn mint_with_token_uri_check_id(681		&mut self,682		caller: caller,683		to: address,684		token_id: uint256,685		token_uri: string,686	) -> Result<bool> {687		let key = key::url();688		let permission = get_token_permission::<T>(self.id, &key)?;689		if !permission.collection_admin {690			return Err("Operation is not allowed".into());691		}692693		let caller = T::CrossAccountId::from_eth(caller);694		let to = T::CrossAccountId::from_eth(to);695		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;696		let budget = self697			.recorder698			.weight_calls_budget(<StructureWeight<T>>::find_parent());699700		if <TokensMinted<T>>::get(self.id)701			.checked_add(1)702			.ok_or("item id overflow")?703			!= token_id704		{705			return Err("item id should be next".into());706		}707708		let mut properties = CollectionPropertiesVec::default();709		properties710			.try_push(Property {711				key,712				value: token_uri713					.into_bytes()714					.try_into()715					.map_err(|_| "token uri is too long")?,716			})717			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;718719		let users = [(to.clone(), 1)]720			.into_iter()721			.collect::<BTreeMap<_, _>>()722			.try_into()723			.unwrap();724		<Pallet<T>>::create_item(725			self,726			&caller,727			CreateItemData::<T> { users, properties },728			&budget,729		)730		.map_err(dispatch_to_evm::<T>)?;731		Ok(true)732	}733734	/// @dev Not implemented735	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {736		Err("not implementable".into())737	}738}739740fn get_token_property<T: Config>(741	collection: &CollectionHandle<T>,742	token_id: u32,743	key: &up_data_structs::PropertyKey,744) -> Result<string> {745	collection.consume_store_reads(1)?;746	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))747		.map_err(|_| Error::Revert("Token properties not found".into()))?;748	if let Some(property) = properties.get(key) {749		return Ok(string::from_utf8_lossy(property).into());750	}751752	Err("Property tokenURI not found".into())753}754755fn get_token_permission<T: Config>(756	collection_id: CollectionId,757	key: &PropertyKey,758) -> Result<PropertyPermission> {759	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)760		.map_err(|_| Error::Revert("No permissions for collection".into()))?;761	let a = token_property_permissions762		.get(key)763		.map(Clone::clone)764		.ok_or_else(|| {765			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();766			Error::Revert(alloc::format!("No permission for key {}", key))767		})?;768	Ok(a)769}770771/// @title Unique extensions for ERC721.772#[solidity_interface(name = ERC721UniqueExtensions)]773impl<T: Config> RefungibleHandle<T>774where775	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,776{777	/// @notice A descriptive name for a collection of NFTs in this contract778	fn name(&self) -> Result<string> {779		Ok(decode_utf16(self.name.iter().copied())780			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))781			.collect::<string>())782	}783784	/// @notice An abbreviated name for NFTs in this contract785	fn symbol(&self) -> Result<string> {786		Ok(string::from_utf8_lossy(&self.token_prefix).into())787	}788789	/// @notice A description for the collection.790	fn description(&self) -> Result<string> {791		Ok(decode_utf16(self.description.iter().copied())792			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))793			.collect::<string>())794	}795796	/// Returns the owner (in cross format) of the token.797	///798	/// @param tokenId Id for the token.799	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAccount> {800		Self::token_owner(&self, token_id.try_into()?)801			.map(|o| pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(&o))802			.ok_or(Error::Revert("key too large".into()))803	}804805	/// Returns the token properties.806	///807	/// @param tokenId Id for the token.808	/// @param keys Properties keys. Empty keys for all propertyes.809	/// @return Vector of properties key/value pairs.810	fn properties(811		&self,812		token_id: uint256,813		keys: Vec<string>,814	) -> Result<Vec<pallet_common::eth::Property>> {815		let keys = keys816			.into_iter()817			.map(|key| {818				<Vec<u8>>::from(key)819					.try_into()820					.map_err(|_| Error::Revert("key too large".into()))821			})822			.collect::<Result<Vec<_>>>()?;823824		<Self as CommonCollectionOperations<T>>::token_properties(825			&self,826			token_id.try_into()?,827			if keys.is_empty() { None } else { Some(keys) },828		)829		.into_iter()830		.map(|p| {831			let key = string::from_utf8(p.key.to_vec())832				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;833			let value = bytes(p.value.to_vec());834			Ok(pallet_common::eth::Property { key, value })835		})836		.collect::<Result<Vec<_>>>()837	}838	/// @notice Transfer ownership of an RFT839	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`840	///  is the zero address. Throws if `tokenId` is not a valid RFT.841	///  Throws if RFT pieces have multiple owners.842	/// @param to The new owner843	/// @param tokenId The RFT to transfer844	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]845	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {846		let caller = T::CrossAccountId::from_eth(caller);847		let to = T::CrossAccountId::from_eth(to);848		let token = token_id.try_into()?;849		let budget = self850			.recorder851			.weight_calls_budget(<StructureWeight<T>>::find_parent());852853		let balance = balance(self, token, &caller)?;854		ensure_single_owner(self, token, balance)?;855856		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)857			.map_err(dispatch_to_evm::<T>)?;858		Ok(())859	}860861	/// @notice Transfer ownership of an RFT862	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`863	///  is the zero address. Throws if `tokenId` is not a valid RFT.864	///  Throws if RFT pieces have multiple owners.865	/// @param to The new owner866	/// @param tokenId The RFT to transfer867	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]868	fn transfer_cross(869		&mut self,870		caller: caller,871		to: pallet_common::eth::CrossAccount,872		token_id: uint256,873	) -> Result<void> {874		let caller = T::CrossAccountId::from_eth(caller);875		let to = to.into_sub_cross_account::<T>()?;876		let token = token_id.try_into()?;877		let budget = self878			.recorder879			.weight_calls_budget(<StructureWeight<T>>::find_parent());880881		let balance = balance(self, token, &caller)?;882		ensure_single_owner(self, token, balance)?;883884		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)885			.map_err(dispatch_to_evm::<T>)?;886		Ok(())887	}888889	/// @notice Transfer ownership of an RFT890	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`891	///  is the zero address. Throws if `tokenId` is not a valid RFT.892	///  Throws if RFT pieces have multiple owners.893	/// @param to The new owner894	/// @param tokenId The RFT to transfer895	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]896	fn transfer_from_cross(897		&mut self,898		caller: caller,899		from: pallet_common::eth::CrossAccount,900		to: pallet_common::eth::CrossAccount,901		token_id: uint256,902	) -> Result<void> {903		let caller = T::CrossAccountId::from_eth(caller);904		let from = from.into_sub_cross_account::<T>()?;905		let to = to.into_sub_cross_account::<T>()?;906		let token_id = token_id.try_into()?;907		let budget = self908			.recorder909			.weight_calls_budget(<StructureWeight<T>>::find_parent());910911		let balance = balance(self, token_id, &from)?;912		ensure_single_owner(self, token_id, balance)?;913914		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)915			.map_err(dispatch_to_evm::<T>)?;916		Ok(())917	}918919	/// @notice Burns a specific ERC721 token.920	/// @dev Throws unless `msg.sender` is the current owner or an authorized921	///  operator for this RFT. Throws if `from` is not the current owner. Throws922	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.923	///  Throws if RFT pieces have multiple owners.924	/// @param from The current owner of the RFT925	/// @param tokenId The RFT to transfer926	#[solidity(hide)]927	#[weight(<SelfWeightOf<T>>::burn_from())]928	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {929		let caller = T::CrossAccountId::from_eth(caller);930		let from = T::CrossAccountId::from_eth(from);931		let token = token_id.try_into()?;932		let budget = self933			.recorder934			.weight_calls_budget(<StructureWeight<T>>::find_parent());935936		let balance = balance(self, token, &from)?;937		ensure_single_owner(self, token, balance)?;938939		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)940			.map_err(dispatch_to_evm::<T>)?;941		Ok(())942	}943944	/// @notice Burns a specific ERC721 token.945	/// @dev Throws unless `msg.sender` is the current owner or an authorized946	///  operator for this RFT. Throws if `from` is not the current owner. Throws947	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.948	///  Throws if RFT pieces have multiple owners.949	/// @param from The current owner of the RFT950	/// @param tokenId The RFT to transfer951	#[weight(<SelfWeightOf<T>>::burn_from())]952	fn burn_from_cross(953		&mut self,954		caller: caller,955		from: pallet_common::eth::CrossAccount,956		token_id: uint256,957	) -> Result<void> {958		let caller = T::CrossAccountId::from_eth(caller);959		let from = from.into_sub_cross_account::<T>()?;960		let token = token_id.try_into()?;961		let budget = self962			.recorder963			.weight_calls_budget(<StructureWeight<T>>::find_parent());964965		let balance = balance(self, token, &from)?;966		ensure_single_owner(self, token, balance)?;967968		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)969			.map_err(dispatch_to_evm::<T>)?;970		Ok(())971	}972973	/// @notice Returns next free RFT ID.974	fn next_token_id(&self) -> Result<uint256> {975		self.consume_store_reads(1)?;976		Ok(<TokensMinted<T>>::get(self.id)977			.checked_add(1)978			.ok_or("item id overflow")?979			.into())980	}981982	/// @notice Function to mint multiple tokens.983	/// @dev `tokenIds` should be an array of consecutive numbers and first number984	///  should be obtained with `nextTokenId` method985	/// @param to The new owner986	/// @param tokenIds IDs of the minted RFTs987	#[solidity(hide)]988	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]989	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {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 total_tokens = token_ids.len();1000		for id in token_ids.into_iter() {1001			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1002			if id != expected_index {1003				return Err("item id should be next".into());1004			}1005			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1006		}1007		let users = [(to.clone(), 1)]1008			.into_iter()1009			.collect::<BTreeMap<_, _>>()1010			.try_into()1011			.unwrap();1012		let create_item_data = CreateItemData::<T> {1013			users,1014			properties: CollectionPropertiesVec::default(),1015		};1016		let data = (0..total_tokens)1017			.map(|_| create_item_data.clone())1018			.collect();10191020		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1021			.map_err(dispatch_to_evm::<T>)?;1022		Ok(true)1023	}10241025	/// @notice Function to mint multiple tokens with the given tokenUris.1026	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1027	///  numbers and first number should be obtained with `nextTokenId` method1028	/// @param to The new owner1029	/// @param tokens array of pairs of token ID and token URI for minted tokens1030	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1031	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1032	fn mint_bulk_with_token_uri(1033		&mut self,1034		caller: caller,1035		to: address,1036		tokens: Vec<(uint256, string)>,1037	) -> Result<bool> {1038		let key = key::url();1039		let caller = T::CrossAccountId::from_eth(caller);1040		let to = T::CrossAccountId::from_eth(to);1041		let mut expected_index = <TokensMinted<T>>::get(self.id)1042			.checked_add(1)1043			.ok_or("item id overflow")?;1044		let budget = self1045			.recorder1046			.weight_calls_budget(<StructureWeight<T>>::find_parent());10471048		let mut data = Vec::with_capacity(tokens.len());1049		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1050			.into_iter()1051			.collect::<BTreeMap<_, _>>()1052			.try_into()1053			.unwrap();1054		for (id, token_uri) in tokens {1055			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1056			if id != expected_index {1057				return Err("item id should be next".into());1058			}1059			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10601061			let mut properties = CollectionPropertiesVec::default();1062			properties1063				.try_push(Property {1064					key: key.clone(),1065					value: token_uri1066						.into_bytes()1067						.try_into()1068						.map_err(|_| "token uri is too long")?,1069				})1070				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10711072			let create_item_data = CreateItemData::<T> {1073				users: users.clone(),1074				properties,1075			};1076			data.push(create_item_data);1077		}10781079		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1080			.map_err(dispatch_to_evm::<T>)?;1081		Ok(true)1082	}10831084	/// @notice Function to mint a token.1085	/// @param to The new owner crossAccountId1086	/// @param properties Properties of minted token1087	/// @return uint256 The id of the newly minted token1088	#[weight(<SelfWeightOf<T>>::create_item())]1089	fn mint_cross(1090		&mut self,1091		caller: caller,1092		to: pallet_common::eth::CrossAccount,1093		properties: Vec<pallet_common::eth::Property>,1094	) -> Result<uint256> {1095		let token_id = <TokensMinted<T>>::get(self.id)1096			.checked_add(1)1097			.ok_or("item id overflow")?;10981099		let to = to.into_sub_cross_account::<T>()?;11001101		let properties = properties1102			.into_iter()1103			.map(|pallet_common::eth::Property { key, value }| {1104				let key = <Vec<u8>>::from(key)1105					.try_into()1106					.map_err(|_| "key too large")?;11071108				let value = value.0.try_into().map_err(|_| "value too large")?;11091110				Ok(Property { key, value })1111			})1112			.collect::<Result<Vec<_>>>()?1113			.try_into()1114			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;11151116		let caller = T::CrossAccountId::from_eth(caller);11171118		let budget = self1119			.recorder1120			.weight_calls_budget(<StructureWeight<T>>::find_parent());11211122		let users = [(to, 1)]1123			.into_iter()1124			.collect::<BTreeMap<_, _>>()1125			.try_into()1126			.unwrap();1127		<Pallet<T>>::create_item(1128			self,1129			&caller,1130			CreateItemData::<T> { users, properties },1131			&budget,1132		)1133		.map_err(dispatch_to_evm::<T>)?;11341135		Ok(token_id.into())1136	}11371138	/// Returns EVM address for refungible token1139	///1140	/// @param token ID of the token1141	fn token_contract_address(&self, token: uint256) -> Result<address> {1142		Ok(T::EvmTokenAddressMapping::token_to_address(1143			self.id,1144			token.try_into().map_err(|_| "token id overflow")?,1145		))1146	}1147}11481149#[solidity_interface(1150	name = UniqueRefungible,1151	is(1152		ERC721,1153		ERC721Enumerable,1154		ERC721UniqueExtensions,1155		ERC721UniqueMintable,1156		ERC721Burnable,1157		ERC721Metadata(if(this.flags.erc721metadata)),1158		Collection(via(common_mut returns CollectionHandle<T>)),1159		TokenProperties,1160	)1161)]1162impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11631164// Not a tests, but code generators1165generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1166generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);11671168impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1169where1170	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1171{1172	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1173	fn call(1174		self,1175		handle: &mut impl PrecompileHandle,1176	) -> Option<pallet_common::erc::PrecompileResult> {1177		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1178	}1179}