git.delta.rocks / unique-network / refs/commits / 08e7d2834a5c

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	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]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 token property value.93	/// @dev Throws error if `msg.sender` has no permission to edit the property.94	/// @param tokenId ID of the token.95	/// @param key Property key.96	/// @param value Property value.97	#[solidity(hide)]98	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]99	fn set_property(100		&mut self,101		caller: caller,102		token_id: uint256,103		key: string,104		value: bytes,105	) -> Result<()> {106		let caller = T::CrossAccountId::from_eth(caller);107		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;108		let key = <Vec<u8>>::from(key)109			.try_into()110			.map_err(|_| "key too long")?;111		let value = value.0.try_into().map_err(|_| "value too long")?;112113		let nesting_budget = self114			.recorder115			.weight_calls_budget(<StructureWeight<T>>::find_parent());116117		<Pallet<T>>::set_token_property(118			self,119			&caller,120			TokenId(token_id),121			Property { key, value },122			&nesting_budget,123		)124		.map_err(dispatch_to_evm::<T>)125	}126127	/// @notice Set token properties value.128	/// @dev Throws error if `msg.sender` has no permission to edit the property.129	/// @param tokenId ID of the token.130	/// @param properties settable properties131	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]132	fn set_properties(133		&mut self,134		caller: caller,135		token_id: uint256,136		properties: Vec<PropertyStruct>,137	) -> Result<()> {138		let caller = T::CrossAccountId::from_eth(caller);139		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;140141		let nesting_budget = self142			.recorder143			.weight_calls_budget(<StructureWeight<T>>::find_parent());144145		let properties = properties146			.into_iter()147			.map(|PropertyStruct { key, value }| {148				let key = <Vec<u8>>::from(key)149					.try_into()150					.map_err(|_| "key too large")?;151152				let value = value.0.try_into().map_err(|_| "value too large")?;153154				Ok(Property { key, value })155			})156			.collect::<Result<Vec<_>>>()?;157158		<Pallet<T>>::set_token_properties(159			self,160			&caller,161			TokenId(token_id),162			properties.into_iter(),163			false,164			&nesting_budget,165		)166		.map_err(dispatch_to_evm::<T>)167	}168169	/// @notice Delete token property value.170	/// @dev Throws error if `msg.sender` has no permission to edit the property.171	/// @param tokenId ID of the token.172	/// @param key Property key.173	#[solidity(hide)]174	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]175	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {176		let caller = T::CrossAccountId::from_eth(caller);177		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;178		let key = <Vec<u8>>::from(key)179			.try_into()180			.map_err(|_| "key too long")?;181182		let nesting_budget = self183			.recorder184			.weight_calls_budget(<StructureWeight<T>>::find_parent());185186		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)187			.map_err(dispatch_to_evm::<T>)188	}189190	/// @notice Delete token properties value.191	/// @dev Throws error if `msg.sender` has no permission to edit the property.192	/// @param tokenId ID of the token.193	/// @param keys Properties key.194	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]195	fn delete_properties(196		&mut self,197		token_id: uint256,198		caller: caller,199		keys: Vec<string>,200	) -> Result<()> {201		let caller = T::CrossAccountId::from_eth(caller);202		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;203		let keys = keys204			.into_iter()205			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))206			.collect::<Result<Vec<_>>>()?;207208		let nesting_budget = self209			.recorder210			.weight_calls_budget(<StructureWeight<T>>::find_parent());211212		<Pallet<T>>::delete_token_properties(213			self,214			&caller,215			TokenId(token_id),216			keys.into_iter(),217			&nesting_budget,218		)219		.map_err(dispatch_to_evm::<T>)220	}221222	/// @notice Get token property value.223	/// @dev Throws error if key not found224	/// @param tokenId ID of the token.225	/// @param key Property key.226	/// @return Property value bytes227	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {228		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;229		let key = <Vec<u8>>::from(key)230			.try_into()231			.map_err(|_| "key too long")?;232233		let props = <TokenProperties<T>>::get((self.id, token_id));234		let prop = props.get(&key).ok_or("key not found")?;235236		Ok(prop.to_vec().into())237	}238}239240#[derive(ToLog)]241pub enum ERC721Events {242	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed243	///  (`to` == 0). Exception: during contract creation, any number of RFTs244	///  may be created and assigned without emitting Transfer.245	Transfer {246		#[indexed]247		from: address,248		#[indexed]249		to: address,250		#[indexed]251		token_id: uint256,252	},253	/// @dev Not supported254	Approval {255		#[indexed]256		owner: address,257		#[indexed]258		approved: address,259		#[indexed]260		token_id: uint256,261	},262	/// @dev Not supported263	#[allow(dead_code)]264	ApprovalForAll {265		#[indexed]266		owner: address,267		#[indexed]268		operator: address,269		approved: bool,270	},271}272273#[derive(ToLog)]274pub enum ERC721UniqueMintableEvents {275	/// @dev Not supported276	#[allow(dead_code)]277	MintingFinished {},278}279280#[solidity_interface(name = ERC721Metadata)]281impl<T: Config> RefungibleHandle<T>282where283	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,284{285	/// @notice A descriptive name for a collection of NFTs in this contract286	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`287	#[solidity(hide, rename_selector = "name")]288	fn name_proxy(&self) -> Result<string> {289		self.name()290	}291292	/// @notice An abbreviated name for NFTs in this contract293	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`294	#[solidity(hide, rename_selector = "symbol")]295	fn symbol_proxy(&self) -> Result<string> {296		self.symbol()297	}298299	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.300	///301	/// @dev If the token has a `url` property and it is not empty, it is returned.302	///  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`.303	///  If the collection property `baseURI` is empty or absent, return "" (empty string)304	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix305	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).306	///307	/// @return token's const_metadata308	#[solidity(rename_selector = "tokenURI")]309	fn token_uri(&self, token_id: uint256) -> Result<string> {310		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;311312		match get_token_property(self, token_id_u32, &key::url()).as_deref() {313			Err(_) | Ok("") => (),314			Ok(url) => {315				return Ok(url.into());316			}317		};318319		let base_uri =320			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())321				.map(BoundedVec::into_inner)322				.map(string::from_utf8)323				.transpose()324				.map_err(|e| {325					Error::Revert(alloc::format!(326						"Can not convert value \"baseURI\" to string with error \"{}\"",327						e328					))329				})?;330331		let base_uri = match base_uri.as_deref() {332			None | Some("") => {333				return Ok("".into());334			}335			Some(base_uri) => base_uri.into(),336		};337338		Ok(339			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {340				Err(_) | Ok("") => base_uri,341				Ok(suffix) => base_uri + suffix,342			},343		)344	}345}346347/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension348/// @dev See https://eips.ethereum.org/EIPS/eip-721349#[solidity_interface(name = ERC721Enumerable)]350impl<T: Config> RefungibleHandle<T> {351	/// @notice Enumerate valid RFTs352	/// @param index A counter less than `totalSupply()`353	/// @return The token identifier for the `index`th NFT,354	///  (sort order not specified)355	fn token_by_index(&self, index: uint256) -> Result<uint256> {356		Ok(index)357	}358359	/// Not implemented360	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {361		// TODO: Not implemetable362		Err("not implemented".into())363	}364365	/// @notice Count RFTs tracked by this contract366	/// @return A count of valid RFTs tracked by this contract, where each one of367	///  them has an assigned and queryable owner not equal to the zero address368	fn total_supply(&self) -> Result<uint256> {369		self.consume_store_reads(1)?;370		Ok(<Pallet<T>>::total_supply(self).into())371	}372}373374/// @title ERC-721 Non-Fungible Token Standard375/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md376#[solidity_interface(name = ERC721, events(ERC721Events))]377impl<T: Config> RefungibleHandle<T> {378	/// @notice Count all RFTs assigned to an owner379	/// @dev RFTs assigned to the zero address are considered invalid, and this380	///  function throws for queries about the zero address.381	/// @param owner An address for whom to query the balance382	/// @return The number of RFTs owned by `owner`, possibly zero383	fn balance_of(&self, owner: address) -> Result<uint256> {384		self.consume_store_reads(1)?;385		let owner = T::CrossAccountId::from_eth(owner);386		let balance = <AccountBalance<T>>::get((self.id, owner));387		Ok(balance.into())388	}389390	/// @notice Find the owner of an RFT391	/// @dev RFTs assigned to zero address are considered invalid, and queries392	///  about them do throw.393	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for394	///  the tokens that are partially owned.395	/// @param tokenId The identifier for an RFT396	/// @return The address of the owner of the RFT397	fn owner_of(&self, token_id: uint256) -> Result<address> {398		self.consume_store_reads(2)?;399		let token = token_id.try_into()?;400		let owner = <Pallet<T>>::token_owner(self.id, token);401		Ok(owner402			.map(|address| *address.as_eth())403			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))404	}405406	/// @dev Not implemented407	fn safe_transfer_from_with_data(408		&mut self,409		_from: address,410		_to: address,411		_token_id: uint256,412		_data: bytes,413	) -> Result<void> {414		// TODO: Not implemetable415		Err("not implemented".into())416	}417418	/// @dev Not implemented419	fn safe_transfer_from(420		&mut self,421		_from: address,422		_to: address,423		_token_id: uint256,424	) -> Result<void> {425		// TODO: Not implemetable426		Err("not implemented".into())427	}428429	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE430	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE431	///  THEY MAY BE PERMANENTLY LOST432	/// @dev Throws unless `msg.sender` is the current owner or an authorized433	///  operator for this RFT. Throws if `from` is not the current owner. Throws434	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.435	///  Throws if RFT pieces have multiple owners.436	/// @param from The current owner of the NFT437	/// @param to The new owner438	/// @param tokenId The NFT to transfer439	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]440	fn transfer_from(441		&mut self,442		caller: caller,443		from: address,444		to: address,445		token_id: uint256,446	) -> Result<void> {447		let caller = T::CrossAccountId::from_eth(caller);448		let from = T::CrossAccountId::from_eth(from);449		let to = T::CrossAccountId::from_eth(to);450		let token = token_id.try_into()?;451		let budget = self452			.recorder453			.weight_calls_budget(<StructureWeight<T>>::find_parent());454455		let balance = balance(&self, token, &from)?;456		ensure_single_owner(&self, token, balance)?;457458		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)459			.map_err(dispatch_to_evm::<T>)?;460461		Ok(())462	}463464	/// @dev Not implemented465	fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {466		Err("not implemented".into())467	}468469	/// @notice Sets or unsets the approval of a given operator.470	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.471	/// @param operator Operator472	/// @param approved Should operator status be granted or revoked?473	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]474	fn set_approval_for_all(475		&mut self,476		caller: caller,477		operator: address,478		approved: bool,479	) -> Result<void> {480		let caller = T::CrossAccountId::from_eth(caller);481		let operator = T::CrossAccountId::from_eth(operator);482483		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)484			.map_err(dispatch_to_evm::<T>)?;485		Ok(())486	}487488	/// @dev Not implemented489	fn get_approved(&self, _token_id: uint256) -> Result<address> {490		// TODO: Not implemetable491		Err("not implemented".into())492	}493494	/// @notice Tells whether the given `owner` approves the `operator`.495	#[weight(<SelfWeightOf<T>>::allowance_for_all())]496	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {497		let owner = T::CrossAccountId::from_eth(owner);498		let operator = T::CrossAccountId::from_eth(operator);499500		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))501	}502503	/// @notice Returns collection helper contract address504	fn collection_helper_address(&self) -> Result<address> {505		Ok(T::ContractAddress::get())506	}507}508509/// Returns amount of pieces of `token` that `owner` have510pub fn balance<T: Config>(511	collection: &RefungibleHandle<T>,512	token: TokenId,513	owner: &T::CrossAccountId,514) -> Result<u128> {515	collection.consume_store_reads(1)?;516	let balance = <Balance<T>>::get((collection.id, token, &owner));517	Ok(balance)518}519520/// Throws if `owner_balance` is lower than total amount of `token` pieces521pub fn ensure_single_owner<T: Config>(522	collection: &RefungibleHandle<T>,523	token: TokenId,524	owner_balance: u128,525) -> Result<()> {526	collection.consume_store_reads(1)?;527	let total_supply = <TotalSupply<T>>::get((collection.id, token));528529	if owner_balance == 0 {530		return Err(dispatch_to_evm::<T>(531			<CommonError<T>>::MustBeTokenOwner.into(),532		));533	}534535	if total_supply != owner_balance {536		return Err("token has multiple owners".into());537	}538	Ok(())539}540541/// @title ERC721 Token that can be irreversibly burned (destroyed).542#[solidity_interface(name = ERC721Burnable)]543impl<T: Config> RefungibleHandle<T> {544	/// @notice Burns a specific ERC721 token.545	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized546	///  operator of the current owner.547	/// @param tokenId The RFT to approve548	#[weight(<SelfWeightOf<T>>::burn_item_fully())]549	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {550		let caller = T::CrossAccountId::from_eth(caller);551		let token = token_id.try_into()?;552553		let balance = balance(&self, token, &caller)?;554		ensure_single_owner(&self, token, balance)?;555556		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;557		Ok(())558	}559}560561/// @title ERC721 minting logic.562#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]563impl<T: Config> RefungibleHandle<T> {564	fn minting_finished(&self) -> Result<bool> {565		Ok(false)566	}567568	/// @notice Function to mint token.569	/// @param to The new owner570	/// @return uint256 The id of the newly minted token571	#[weight(<SelfWeightOf<T>>::create_item())]572	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {573		let token_id: uint256 = <TokensMinted<T>>::get(self.id)574			.checked_add(1)575			.ok_or("item id overflow")?576			.into();577		self.mint_check_id(caller, to, token_id)?;578		Ok(token_id)579	}580581	/// @notice Function to mint token.582	/// @dev `tokenId` should be obtained with `nextTokenId` method,583	///  unlike standard, you can't specify it manually584	/// @param to The new owner585	/// @param tokenId ID of the minted RFT586	#[solidity(hide, rename_selector = "mint")]587	#[weight(<SelfWeightOf<T>>::create_item())]588	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {589		let caller = T::CrossAccountId::from_eth(caller);590		let to = T::CrossAccountId::from_eth(to);591		let token_id: u32 = token_id.try_into()?;592		let budget = self593			.recorder594			.weight_calls_budget(<StructureWeight<T>>::find_parent());595596		if <TokensMinted<T>>::get(self.id)597			.checked_add(1)598			.ok_or("item id overflow")?599			!= token_id600		{601			return Err("item id should be next".into());602		}603604		let users = [(to.clone(), 1)]605			.into_iter()606			.collect::<BTreeMap<_, _>>()607			.try_into()608			.unwrap();609		<Pallet<T>>::create_item(610			self,611			&caller,612			CreateItemData::<T::CrossAccountId> {613				users,614				properties: CollectionPropertiesVec::default(),615			},616			&budget,617		)618		.map_err(dispatch_to_evm::<T>)?;619620		Ok(true)621	}622623	/// @notice Function to mint token with the given tokenUri.624	/// @param to The new owner625	/// @param tokenUri Token URI that would be stored in the NFT properties626	/// @return uint256 The id of the newly minted token627	#[solidity(rename_selector = "mintWithTokenURI")]628	#[weight(<SelfWeightOf<T>>::create_item())]629	fn mint_with_token_uri(630		&mut self,631		caller: caller,632		to: address,633		token_uri: string,634	) -> Result<uint256> {635		let token_id: uint256 = <TokensMinted<T>>::get(self.id)636			.checked_add(1)637			.ok_or("item id overflow")?638			.into();639		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;640		Ok(token_id)641	}642643	/// @notice Function to mint token with the given tokenUri.644	/// @dev `tokenId` should be obtained with `nextTokenId` method,645	///  unlike standard, you can't specify it manually646	/// @param to The new owner647	/// @param tokenId ID of the minted RFT648	/// @param tokenUri Token URI that would be stored in the RFT properties649	#[solidity(hide, rename_selector = "mintWithTokenURI")]650	#[weight(<SelfWeightOf<T>>::create_item())]651	fn mint_with_token_uri_check_id(652		&mut self,653		caller: caller,654		to: address,655		token_id: uint256,656		token_uri: string,657	) -> Result<bool> {658		let key = key::url();659		let permission = get_token_permission::<T>(self.id, &key)?;660		if !permission.collection_admin {661			return Err("Operation is not allowed".into());662		}663664		let caller = T::CrossAccountId::from_eth(caller);665		let to = T::CrossAccountId::from_eth(to);666		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;667		let budget = self668			.recorder669			.weight_calls_budget(<StructureWeight<T>>::find_parent());670671		if <TokensMinted<T>>::get(self.id)672			.checked_add(1)673			.ok_or("item id overflow")?674			!= token_id675		{676			return Err("item id should be next".into());677		}678679		let mut properties = CollectionPropertiesVec::default();680		properties681			.try_push(Property {682				key,683				value: token_uri684					.into_bytes()685					.try_into()686					.map_err(|_| "token uri is too long")?,687			})688			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;689690		let users = [(to.clone(), 1)]691			.into_iter()692			.collect::<BTreeMap<_, _>>()693			.try_into()694			.unwrap();695		<Pallet<T>>::create_item(696			self,697			&caller,698			CreateItemData::<T::CrossAccountId> { users, properties },699			&budget,700		)701		.map_err(dispatch_to_evm::<T>)?;702		Ok(true)703	}704705	/// @dev Not implemented706	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {707		Err("not implementable".into())708	}709}710711fn get_token_property<T: Config>(712	collection: &CollectionHandle<T>,713	token_id: u32,714	key: &up_data_structs::PropertyKey,715) -> Result<string> {716	collection.consume_store_reads(1)?;717	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))718		.map_err(|_| Error::Revert("Token properties not found".into()))?;719	if let Some(property) = properties.get(key) {720		return Ok(string::from_utf8_lossy(property).into());721	}722723	Err("Property tokenURI not found".into())724}725726fn get_token_permission<T: Config>(727	collection_id: CollectionId,728	key: &PropertyKey,729) -> Result<PropertyPermission> {730	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)731		.map_err(|_| Error::Revert("No permissions for collection".into()))?;732	let a = token_property_permissions733		.get(key)734		.map(Clone::clone)735		.ok_or_else(|| {736			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();737			Error::Revert(alloc::format!("No permission for key {}", key))738		})?;739	Ok(a)740}741742/// @title Unique extensions for ERC721.743#[solidity_interface(name = ERC721UniqueExtensions)]744impl<T: Config> RefungibleHandle<T>745where746	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,747{748	/// @notice A descriptive name for a collection of NFTs in this contract749	fn name(&self) -> Result<string> {750		Ok(decode_utf16(self.name.iter().copied())751			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))752			.collect::<string>())753	}754755	/// @notice An abbreviated name for NFTs in this contract756	fn symbol(&self) -> Result<string> {757		Ok(string::from_utf8_lossy(&self.token_prefix).into())758	}759760	/// @notice A description for the collection.761	fn description(&self) -> Result<string> {762		Ok(decode_utf16(self.description.iter().copied())763			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))764			.collect::<string>())765	}766767	/// Returns the owner (in cross format) of the token.768	///769	/// @param tokenId Id for the token.770	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {771		Self::token_owner(&self, token_id.try_into()?)772			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))773			.ok_or(Error::Revert("key too large".into()))774	}775776	/// Returns the token properties.777	///778	/// @param tokenId Id for the token.779	/// @param keys Properties keys. Empty keys for all propertyes.780	/// @return Vector of properties key/value pairs.781	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {782		let keys = keys783			.into_iter()784			.map(|key| {785				<Vec<u8>>::from(key)786					.try_into()787					.map_err(|_| Error::Revert("key too large".into()))788			})789			.collect::<Result<Vec<_>>>()?;790791		<Self as CommonCollectionOperations<T>>::token_properties(792			&self,793			token_id.try_into()?,794			if keys.is_empty() { None } else { Some(keys) },795		)796		.into_iter()797		.map(|p| {798			let key = string::from_utf8(p.key.to_vec())799				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;800			let value = bytes(p.value.to_vec());801			Ok(PropertyStruct { key, value })802		})803		.collect::<Result<Vec<_>>>()804	}805	/// @notice Transfer ownership of an RFT806	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`807	///  is the zero address. Throws if `tokenId` is not a valid RFT.808	///  Throws if RFT pieces have multiple owners.809	/// @param to The new owner810	/// @param tokenId The RFT to transfer811	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]812	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {813		let caller = T::CrossAccountId::from_eth(caller);814		let to = T::CrossAccountId::from_eth(to);815		let token = token_id.try_into()?;816		let budget = self817			.recorder818			.weight_calls_budget(<StructureWeight<T>>::find_parent());819820		let balance = balance(self, token, &caller)?;821		ensure_single_owner(self, token, balance)?;822823		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)824			.map_err(dispatch_to_evm::<T>)?;825		Ok(())826	}827828	/// @notice Transfer ownership of an RFT829	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`830	///  is the zero address. Throws if `tokenId` is not a valid RFT.831	///  Throws if RFT pieces have multiple owners.832	/// @param to The new owner833	/// @param tokenId The RFT to transfer834	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]835	fn transfer_cross(836		&mut self,837		caller: caller,838		to: EthCrossAccount,839		token_id: uint256,840	) -> Result<void> {841		let caller = T::CrossAccountId::from_eth(caller);842		let to = to.into_sub_cross_account::<T>()?;843		let token = token_id.try_into()?;844		let budget = self845			.recorder846			.weight_calls_budget(<StructureWeight<T>>::find_parent());847848		let balance = balance(self, token, &caller)?;849		ensure_single_owner(self, token, balance)?;850851		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)852			.map_err(dispatch_to_evm::<T>)?;853		Ok(())854	}855856	/// @notice Transfer ownership of an RFT857	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`858	///  is the zero address. Throws if `tokenId` is not a valid RFT.859	///  Throws if RFT pieces have multiple owners.860	/// @param to The new owner861	/// @param tokenId The RFT to transfer862	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]863	fn transfer_from_cross(864		&mut self,865		caller: caller,866		from: EthCrossAccount,867		to: EthCrossAccount,868		token_id: uint256,869	) -> Result<void> {870		let caller = T::CrossAccountId::from_eth(caller);871		let from = from.into_sub_cross_account::<T>()?;872		let to = to.into_sub_cross_account::<T>()?;873		let token_id = token_id.try_into()?;874		let budget = self875			.recorder876			.weight_calls_budget(<StructureWeight<T>>::find_parent());877878		let balance = balance(self, token_id, &from)?;879		ensure_single_owner(self, token_id, balance)?;880881		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)882			.map_err(dispatch_to_evm::<T>)?;883		Ok(())884	}885886	/// @notice Burns a specific ERC721 token.887	/// @dev Throws unless `msg.sender` is the current owner or an authorized888	///  operator for this RFT. Throws if `from` is not the current owner. Throws889	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.890	///  Throws if RFT pieces have multiple owners.891	/// @param from The current owner of the RFT892	/// @param tokenId The RFT to transfer893	#[solidity(hide)]894	#[weight(<SelfWeightOf<T>>::burn_from())]895	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {896		let caller = T::CrossAccountId::from_eth(caller);897		let from = T::CrossAccountId::from_eth(from);898		let token = token_id.try_into()?;899		let budget = self900			.recorder901			.weight_calls_budget(<StructureWeight<T>>::find_parent());902903		let balance = balance(self, token, &from)?;904		ensure_single_owner(self, token, balance)?;905906		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)907			.map_err(dispatch_to_evm::<T>)?;908		Ok(())909	}910911	/// @notice Burns a specific ERC721 token.912	/// @dev Throws unless `msg.sender` is the current owner or an authorized913	///  operator for this RFT. Throws if `from` is not the current owner. Throws914	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.915	///  Throws if RFT pieces have multiple owners.916	/// @param from The current owner of the RFT917	/// @param tokenId The RFT to transfer918	#[weight(<SelfWeightOf<T>>::burn_from())]919	fn burn_from_cross(920		&mut self,921		caller: caller,922		from: EthCrossAccount,923		token_id: uint256,924	) -> Result<void> {925		let caller = T::CrossAccountId::from_eth(caller);926		let from = from.into_sub_cross_account::<T>()?;927		let token = token_id.try_into()?;928		let budget = self929			.recorder930			.weight_calls_budget(<StructureWeight<T>>::find_parent());931932		let balance = balance(self, token, &from)?;933		ensure_single_owner(self, token, balance)?;934935		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)936			.map_err(dispatch_to_evm::<T>)?;937		Ok(())938	}939940	/// @notice Returns next free RFT ID.941	fn next_token_id(&self) -> Result<uint256> {942		self.consume_store_reads(1)?;943		Ok(<TokensMinted<T>>::get(self.id)944			.checked_add(1)945			.ok_or("item id overflow")?946			.into())947	}948949	/// @notice Function to mint multiple tokens.950	/// @dev `tokenIds` should be an array of consecutive numbers and first number951	///  should be obtained with `nextTokenId` method952	/// @param to The new owner953	/// @param tokenIds IDs of the minted RFTs954	#[solidity(hide)]955	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]956	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {957		let caller = T::CrossAccountId::from_eth(caller);958		let to = T::CrossAccountId::from_eth(to);959		let mut expected_index = <TokensMinted<T>>::get(self.id)960			.checked_add(1)961			.ok_or("item id overflow")?;962		let budget = self963			.recorder964			.weight_calls_budget(<StructureWeight<T>>::find_parent());965966		let total_tokens = token_ids.len();967		for id in token_ids.into_iter() {968			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;969			if id != expected_index {970				return Err("item id should be next".into());971			}972			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;973		}974		let users = [(to.clone(), 1)]975			.into_iter()976			.collect::<BTreeMap<_, _>>()977			.try_into()978			.unwrap();979		let create_item_data = CreateItemData::<T::CrossAccountId> {980			users,981			properties: CollectionPropertiesVec::default(),982		};983		let data = (0..total_tokens)984			.map(|_| create_item_data.clone())985			.collect();986987		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)988			.map_err(dispatch_to_evm::<T>)?;989		Ok(true)990	}991992	/// @notice Function to mint multiple tokens with the given tokenUris.993	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive994	///  numbers and first number should be obtained with `nextTokenId` method995	/// @param to The new owner996	/// @param tokens array of pairs of token ID and token URI for minted tokens997	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]998	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]999	fn mint_bulk_with_token_uri(1000		&mut self,1001		caller: caller,1002		to: address,1003		tokens: Vec<(uint256, string)>,1004	) -> Result<bool> {1005		let key = key::url();1006		let caller = T::CrossAccountId::from_eth(caller);1007		let to = T::CrossAccountId::from_eth(to);1008		let mut expected_index = <TokensMinted<T>>::get(self.id)1009			.checked_add(1)1010			.ok_or("item id overflow")?;1011		let budget = self1012			.recorder1013			.weight_calls_budget(<StructureWeight<T>>::find_parent());10141015		let mut data = Vec::with_capacity(tokens.len());1016		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1017			.into_iter()1018			.collect::<BTreeMap<_, _>>()1019			.try_into()1020			.unwrap();1021		for (id, token_uri) in tokens {1022			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1023			if id != expected_index {1024				return Err("item id should be next".into());1025			}1026			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10271028			let mut properties = CollectionPropertiesVec::default();1029			properties1030				.try_push(Property {1031					key: key.clone(),1032					value: token_uri1033						.into_bytes()1034						.try_into()1035						.map_err(|_| "token uri is too long")?,1036				})1037				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10381039			let create_item_data = CreateItemData::<T::CrossAccountId> {1040				users: users.clone(),1041				properties,1042			};1043			data.push(create_item_data);1044		}10451046		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1047			.map_err(dispatch_to_evm::<T>)?;1048		Ok(true)1049	}10501051	/// Returns EVM address for refungible token1052	///1053	/// @param token ID of the token1054	fn token_contract_address(&self, token: uint256) -> Result<address> {1055		Ok(T::EvmTokenAddressMapping::token_to_address(1056			self.id,1057			token.try_into().map_err(|_| "token id overflow")?,1058		))1059	}1060}10611062#[solidity_interface(1063	name = UniqueRefungible,1064	is(1065		ERC721,1066		ERC721Enumerable,1067		ERC721UniqueExtensions,1068		ERC721UniqueMintable,1069		ERC721Burnable,1070		ERC721Metadata(if(this.flags.erc721metadata)),1071		Collection(via(common_mut returns CollectionHandle<T>)),1072		TokenProperties,1073	)1074)]1075impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10761077// Not a tests, but code generators1078generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1079generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);10801081impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1082where1083	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1084{1085	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1086	fn call(1087		self,1088		handle: &mut impl PrecompileHandle,1089	) -> Option<pallet_common::erc::PrecompileResult> {1090		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1091	}1092}