git.delta.rocks / unique-network / refs/commits / 7d1859c1e151

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 alloc::string::ToString;25use core::{26	char::{REPLACEMENT_CHARACTER, decode_utf16},27	convert::TryInto,28};29use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};30use frame_support::{BoundedBTreeMap, BoundedVec};31use pallet_common::{32	CollectionHandle, CollectionPropertyPermissions,33	erc::{34		CommonEvmHandler, CollectionCall,35		static_property::{key, value as property_value},36	},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;42use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};43use up_data_structs::{44	CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,45	PropertyPermission, TokenId,46};4748use crate::{49	AccountBalance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,50	TokenProperties, TokensMinted, weights::WeightInfo,51};5253/// @title A contract that allows to set and delete token properties and change token property permissions.54#[solidity_interface(name = "TokenProperties")]55impl<T: Config> RefungibleHandle<T> {56	/// @notice Set permissions for token property.57	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.58	/// @param key Property key.59	/// @param is_mutable Permission to mutate property.60	/// @param collection_admin Permission to mutate property by collection admin if property is mutable.61	/// @param token_owner Permission to mutate property by token owner if property is mutable.62	fn set_token_property_permission(63		&mut self,64		caller: caller,65		key: string,66		is_mutable: bool,67		collection_admin: bool,68		token_owner: bool,69	) -> Result<()> {70		let caller = T::CrossAccountId::from_eth(caller);71		<Pallet<T>>::set_token_property_permissions(72			self,73			&caller,74			vec![PropertyKeyPermission {75				key: <Vec<u8>>::from(key)76					.try_into()77					.map_err(|_| "too long key")?,78				permission: PropertyPermission {79					mutable: is_mutable,80					collection_admin,81					token_owner,82				},83			}],84		)85		.map_err(dispatch_to_evm::<T>)86	}8788	/// @notice Set token property value.89	/// @dev Throws error if `msg.sender` has no permission to edit the property.90	/// @param tokenId ID of the token.91	/// @param key Property key.92	/// @param value Property value.93	fn set_property(94		&mut self,95		caller: caller,96		token_id: uint256,97		key: string,98		value: bytes,99	) -> Result<()> {100		let caller = T::CrossAccountId::from_eth(caller);101		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;102		let key = <Vec<u8>>::from(key)103			.try_into()104			.map_err(|_| "key too long")?;105		let value = value.try_into().map_err(|_| "value too long")?;106107		let nesting_budget = self108			.recorder109			.weight_calls_budget(<StructureWeight<T>>::find_parent());110111		<Pallet<T>>::set_token_property(112			self,113			&caller,114			TokenId(token_id),115			Property { key, value },116			&nesting_budget,117		)118		.map_err(dispatch_to_evm::<T>)119	}120121	/// @notice Delete 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	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {126		let caller = T::CrossAccountId::from_eth(caller);127		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;128		let key = <Vec<u8>>::from(key)129			.try_into()130			.map_err(|_| "key too long")?;131132		let nesting_budget = self133			.recorder134			.weight_calls_budget(<StructureWeight<T>>::find_parent());135136		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)137			.map_err(dispatch_to_evm::<T>)138	}139140	/// @notice Get token property value.141	/// @dev Throws error if key not found142	/// @param tokenId ID of the token.143	/// @param key Property key.144	/// @return Property value bytes145	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {146		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;147		let key = <Vec<u8>>::from(key)148			.try_into()149			.map_err(|_| "key too long")?;150151		let props = <TokenProperties<T>>::get((self.id, token_id));152		let prop = props.get(&key).ok_or("key not found")?;153154		Ok(prop.to_vec())155	}156}157158#[derive(ToLog)]159pub enum ERC721Events {160	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed161	///  (`to` == 0). Exception: during contract creation, any number of RFTs162	///  may be created and assigned without emitting Transfer.163	Transfer {164		#[indexed]165		from: address,166		#[indexed]167		to: address,168		#[indexed]169		token_id: uint256,170	},171	/// @dev Not supported172	Approval {173		#[indexed]174		owner: address,175		#[indexed]176		approved: address,177		#[indexed]178		token_id: uint256,179	},180	/// @dev Not supported181	#[allow(dead_code)]182	ApprovalForAll {183		#[indexed]184		owner: address,185		#[indexed]186		operator: address,187		approved: bool,188	},189}190191#[derive(ToLog)]192pub enum ERC721MintableEvents {193	/// @dev Not supported194	#[allow(dead_code)]195	MintingFinished {},196}197198#[solidity_interface(name = "ERC721Metadata")]199impl<T: Config> RefungibleHandle<T> {200	/// @notice A descriptive name for a collection of RFTs in this contract201	fn name(&self) -> Result<string> {202		Ok(decode_utf16(self.name.iter().copied())203			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))204			.collect::<string>())205	}206207	/// @notice An abbreviated name for RFTs in this contract208	fn symbol(&self) -> Result<string> {209		Ok(string::from_utf8_lossy(&self.token_prefix).into())210	}211212	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.213	///214	/// @dev If the token has a `url` property and it is not empty, it is returned.215	///  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`.216	///  If the collection property `baseURI` is empty or absent, return "" (empty string)217	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix218	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).219	///220	/// @return token's const_metadata221	#[solidity(rename_selector = "tokenURI")]222	fn token_uri(&self, token_id: uint256) -> Result<string> {223		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;224225		if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {226			if !url.is_empty() {227				return Ok(url);228			}229		} else if !is_erc721_metadata_compatible::<T>(self.id) {230			return Err("tokenURI not set".into());231		}232233		if let Some(base_uri) =234			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())235		{236			if !base_uri.is_empty() {237				let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {238					Error::Revert(alloc::format!(239						"Can not convert value \"baseURI\" to string with error \"{}\"",240						e241					))242				})?;243				if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {244					if !suffix.is_empty() {245						return Ok(base_uri + suffix.as_str());246					}247				}248249				return Ok(base_uri + token_id.to_string().as_str());250			}251		}252253		Ok("".into())254	}255}256257/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension258/// @dev See https://eips.ethereum.org/EIPS/eip-721259#[solidity_interface(name = "ERC721Enumerable")]260impl<T: Config> RefungibleHandle<T> {261	/// @notice Enumerate valid RFTs262	/// @param index A counter less than `totalSupply()`263	/// @return The token identifier for the `index`th NFT,264	///  (sort order not specified)265	fn token_by_index(&self, index: uint256) -> Result<uint256> {266		Ok(index)267	}268269	/// Not implemented270	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {271		// TODO: Not implemetable272		Err("not implemented".into())273	}274275	/// @notice Count RFTs tracked by this contract276	/// @return A count of valid RFTs tracked by this contract, where each one of277	///  them has an assigned and queryable owner not equal to the zero address278	fn total_supply(&self) -> Result<uint256> {279		self.consume_store_reads(1)?;280		Ok(<Pallet<T>>::total_supply(self).into())281	}282}283284/// @title ERC-721 Non-Fungible Token Standard285/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md286#[solidity_interface(name = "ERC721", events(ERC721Events))]287impl<T: Config> RefungibleHandle<T> {288	/// @notice Count all RFTs assigned to an owner289	/// @dev RFTs assigned to the zero address are considered invalid, and this290	///  function throws for queries about the zero address.291	/// @param owner An address for whom to query the balance292	/// @return The number of RFTs owned by `owner`, possibly zero293	fn balance_of(&self, owner: address) -> Result<uint256> {294		self.consume_store_reads(1)?;295		let owner = T::CrossAccountId::from_eth(owner);296		let balance = <AccountBalance<T>>::get((self.id, owner));297		Ok(balance.into())298	}299300	fn owner_of(&self, token_id: uint256) -> Result<address> {301		self.consume_store_reads(2)?;302		let token = token_id.try_into()?;303		let owner = <Pallet<T>>::token_owner(self.id, token);304		Ok(owner305			.map(|address| *address.as_eth())306			.unwrap_or_else(|| H160::default()))307	}308309	/// @dev Not implemented310	fn safe_transfer_from_with_data(311		&mut self,312		_from: address,313		_to: address,314		_token_id: uint256,315		_data: bytes,316		_value: value,317	) -> Result<void> {318		// TODO: Not implemetable319		Err("not implemented".into())320	}321322	/// @dev Not implemented323	fn safe_transfer_from(324		&mut self,325		_from: address,326		_to: address,327		_token_id: uint256,328		_value: value,329	) -> Result<void> {330		// TODO: Not implemetable331		Err("not implemented".into())332	}333334	/// @dev Not implemented335	fn transfer_from(336		&mut self,337		_caller: caller,338		_from: address,339		_to: address,340		_token_id: uint256,341		_value: value,342	) -> Result<void> {343		Err("not implemented".into())344	}345346	/// @dev Not implemented347	fn approve(348		&mut self,349		_caller: caller,350		_approved: address,351		_token_id: uint256,352		_value: value,353	) -> Result<void> {354		Err("not implemented".into())355	}356357	/// @dev Not implemented358	fn set_approval_for_all(359		&mut self,360		_caller: caller,361		_operator: address,362		_approved: bool,363	) -> Result<void> {364		// TODO: Not implemetable365		Err("not implemented".into())366	}367368	/// @dev Not implemented369	fn get_approved(&self, _token_id: uint256) -> Result<address> {370		// TODO: Not implemetable371		Err("not implemented".into())372	}373374	/// @dev Not implemented375	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {376		// TODO: Not implemetable377		Err("not implemented".into())378	}379}380381/// @title ERC721 Token that can be irreversibly burned (destroyed).382#[solidity_interface(name = "ERC721Burnable")]383impl<T: Config> RefungibleHandle<T> {384	/// @dev Not implemented385	fn burn(&mut self, _caller: caller, _token_id: uint256, _value: value) -> Result<void> {386		Err("not implemented".into())387	}388}389390/// @title ERC721 minting logic.391#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]392impl<T: Config> RefungibleHandle<T> {393	fn minting_finished(&self) -> Result<bool> {394		Ok(false)395	}396397	/// @notice Function to mint token.398	/// @dev `tokenId` should be obtained with `nextTokenId` method,399	///  unlike standard, you can't specify it manually400	/// @param to The new owner401	/// @param tokenId ID of the minted RFT402	#[weight(<SelfWeightOf<T>>::create_item())]403	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {404		let caller = T::CrossAccountId::from_eth(caller);405		let to = T::CrossAccountId::from_eth(to);406		let token_id: u32 = token_id.try_into()?;407		let budget = self408			.recorder409			.weight_calls_budget(<StructureWeight<T>>::find_parent());410411		if <TokensMinted<T>>::get(self.id)412			.checked_add(1)413			.ok_or("item id overflow")?414			!= token_id415		{416			return Err("item id should be next".into());417		}418419		let const_data = BoundedVec::default();420		let users = [(to.clone(), 1)]421			.into_iter()422			.collect::<BTreeMap<_, _>>()423			.try_into()424			.unwrap();425		<Pallet<T>>::create_item(426			self,427			&caller,428			CreateItemData::<T> {429				const_data,430				users,431				properties: CollectionPropertiesVec::default(),432			},433			&budget,434		)435		.map_err(dispatch_to_evm::<T>)?;436437		Ok(true)438	}439440	/// @notice Function to mint token with the given tokenUri.441	/// @dev `tokenId` should be obtained with `nextTokenId` method,442	///  unlike standard, you can't specify it manually443	/// @param to The new owner444	/// @param tokenId ID of the minted RFT445	/// @param tokenUri Token URI that would be stored in the RFT properties446	#[solidity(rename_selector = "mintWithTokenURI")]447	#[weight(<SelfWeightOf<T>>::create_item())]448	fn mint_with_token_uri(449		&mut self,450		caller: caller,451		to: address,452		token_id: uint256,453		token_uri: string,454	) -> Result<bool> {455		let key = key::url();456		let permission = get_token_permission::<T>(self.id, &key)?;457		if !permission.collection_admin {458			return Err("Operation is not allowed".into());459		}460461		let caller = T::CrossAccountId::from_eth(caller);462		let to = T::CrossAccountId::from_eth(to);463		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;464		let budget = self465			.recorder466			.weight_calls_budget(<StructureWeight<T>>::find_parent());467468		if <TokensMinted<T>>::get(self.id)469			.checked_add(1)470			.ok_or("item id overflow")?471			!= token_id472		{473			return Err("item id should be next".into());474		}475476		let mut properties = CollectionPropertiesVec::default();477		properties478			.try_push(Property {479				key,480				value: token_uri481					.into_bytes()482					.try_into()483					.map_err(|_| "token uri is too long")?,484			})485			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;486487		let const_data = BoundedVec::default();488		let users = [(to.clone(), 1)]489			.into_iter()490			.collect::<BTreeMap<_, _>>()491			.try_into()492			.unwrap();493		<Pallet<T>>::create_item(494			self,495			&caller,496			CreateItemData::<T> {497				const_data,498				users,499				properties,500			},501			&budget,502		)503		.map_err(dispatch_to_evm::<T>)?;504		Ok(true)505	}506507	/// @dev Not implemented508	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {509		Err("not implementable".into())510	}511}512513fn get_token_property<T: Config>(514	collection: &CollectionHandle<T>,515	token_id: u32,516	key: &up_data_structs::PropertyKey,517) -> Result<string> {518	collection.consume_store_reads(1)?;519	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))520		.map_err(|_| Error::Revert("Token properties not found".into()))?;521	if let Some(property) = properties.get(key) {522		return Ok(string::from_utf8_lossy(property).into());523	}524525	Err("Property tokenURI not found".into())526}527528fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {529	if let Some(shema_name) =530		pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())531	{532		let shema_name = shema_name.into_inner();533		shema_name == property_value::ERC721_METADATA534	} else {535		false536	}537}538539fn get_token_permission<T: Config>(540	collection_id: CollectionId,541	key: &PropertyKey,542) -> Result<PropertyPermission> {543	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)544		.map_err(|_| Error::Revert("No permissions for collection".into()))?;545	let a = token_property_permissions546		.get(key)547		.map(Clone::clone)548		.ok_or_else(|| {549			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();550			Error::Revert(alloc::format!("No permission for key {}", key))551		})?;552	Ok(a)553}554555/// @title Unique extensions for ERC721.556#[solidity_interface(name = "ERC721UniqueExtensions")]557impl<T: Config> RefungibleHandle<T> {558	/// @notice Returns next free RFT ID.559	fn next_token_id(&self) -> Result<uint256> {560		self.consume_store_reads(1)?;561		Ok(<TokensMinted<T>>::get(self.id)562			.checked_add(1)563			.ok_or("item id overflow")?564			.into())565	}566567	/// @notice Function to mint multiple tokens.568	/// @dev `tokenIds` should be an array of consecutive numbers and first number569	///  should be obtained with `nextTokenId` method570	/// @param to The new owner571	/// @param tokenIds IDs of the minted RFTs572	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]573	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {574		let caller = T::CrossAccountId::from_eth(caller);575		let to = T::CrossAccountId::from_eth(to);576		let mut expected_index = <TokensMinted<T>>::get(self.id)577			.checked_add(1)578			.ok_or("item id overflow")?;579		let budget = self580			.recorder581			.weight_calls_budget(<StructureWeight<T>>::find_parent());582583		let total_tokens = token_ids.len();584		for id in token_ids.into_iter() {585			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;586			if id != expected_index {587				return Err("item id should be next".into());588			}589			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;590		}591		let const_data = BoundedVec::default();592		let users = [(to.clone(), 1)]593			.into_iter()594			.collect::<BTreeMap<_, _>>()595			.try_into()596			.unwrap();597		let create_item_data = CreateItemData::<T> {598			const_data,599			users,600			properties: CollectionPropertiesVec::default(),601		};602		let data = (0..total_tokens)603			.map(|_| create_item_data.clone())604			.collect();605606		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)607			.map_err(dispatch_to_evm::<T>)?;608		Ok(true)609	}610611	/// @notice Function to mint multiple tokens with the given tokenUris.612	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive613	///  numbers and first number should be obtained with `nextTokenId` method614	/// @param to The new owner615	/// @param tokens array of pairs of token ID and token URI for minted tokens616	#[solidity(rename_selector = "mintBulkWithTokenURI")]617	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]618	fn mint_bulk_with_token_uri(619		&mut self,620		caller: caller,621		to: address,622		tokens: Vec<(uint256, string)>,623	) -> Result<bool> {624		let key = key::url();625		let caller = T::CrossAccountId::from_eth(caller);626		let to = T::CrossAccountId::from_eth(to);627		let mut expected_index = <TokensMinted<T>>::get(self.id)628			.checked_add(1)629			.ok_or("item id overflow")?;630		let budget = self631			.recorder632			.weight_calls_budget(<StructureWeight<T>>::find_parent());633634		let mut data = Vec::with_capacity(tokens.len());635		let const_data = BoundedVec::default();636		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]637			.into_iter()638			.collect::<BTreeMap<_, _>>()639			.try_into()640			.unwrap();641		for (id, token_uri) in tokens {642			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;643			if id != expected_index {644				return Err("item id should be next".into());645			}646			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;647648			let mut properties = CollectionPropertiesVec::default();649			properties650				.try_push(Property {651					key: key.clone(),652					value: token_uri653						.into_bytes()654						.try_into()655						.map_err(|_| "token uri is too long")?,656				})657				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;658659			let create_item_data = CreateItemData::<T> {660				const_data: const_data.clone(),661				users: users.clone(),662				properties,663			};664			data.push(create_item_data);665		}666667		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)668			.map_err(dispatch_to_evm::<T>)?;669		Ok(true)670	}671}672673#[solidity_interface(674	name = "UniqueRefungible",675	is(676		ERC721,677		ERC721Metadata,678		ERC721Enumerable,679		ERC721UniqueExtensions,680		ERC721Mintable,681		ERC721Burnable,682		via("CollectionHandle<T>", common_mut, Collection),683		TokenProperties,684	)685)]686impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}687688// Not a tests, but code generators689generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);690generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);691692impl<T: Config> CommonEvmHandler for RefungibleHandle<T>693where694	T::AccountId: From<[u8; 32]>,695{696	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");697	fn call(698		self,699		handle: &mut impl PrecompileHandle,700	) -> Option<pallet_common::erc::PrecompileResult> {701		call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)702	}703}