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

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/>.1617extern crate alloc;18use core::{19	char::{REPLACEMENT_CHARACTER, decode_utf16},20	convert::TryInto,21};22use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};23use frame_support::BoundedVec;24use up_data_structs::{25	TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey,26	CollectionPropertiesVec,27};28use pallet_evm_coder_substrate::dispatch_to_evm;29use sp_std::vec::Vec;30use pallet_common::{31	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, token_uri_key},32	CollectionHandle, CollectionPropertyPermissions,33};34use pallet_evm::{account::CrossAccountId, PrecompileHandle};35use pallet_evm_coder_substrate::call;36use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};3738use crate::{39	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,40	SelfWeightOf, weights::WeightInfo, TokenProperties,41};4243#[solidity_interface(name = "TokenProperties")]44impl<T: Config> NonfungibleHandle<T> {45	fn set_token_property_permission(46		&mut self,47		caller: caller,48		key: string,49		is_mutable: bool,50		collection_admin: bool,51		token_owner: bool,52	) -> Result<()> {53		let caller = T::CrossAccountId::from_eth(caller);54		<Pallet<T>>::set_property_permission(55			self,56			&caller,57			PropertyKeyPermission {58				key: <Vec<u8>>::from(key)59					.try_into()60					.map_err(|_| "too long key")?,61				permission: PropertyPermission {62					mutable: is_mutable,63					collection_admin,64					token_owner,65				},66			},67		)68		.map_err(dispatch_to_evm::<T>)69	}7071	fn set_property(72		&mut self,73		caller: caller,74		token_id: uint256,75		key: string,76		value: bytes,77	) -> Result<()> {78		let caller = T::CrossAccountId::from_eth(caller);79		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;80		let key = <Vec<u8>>::from(key)81			.try_into()82			.map_err(|_| "key too long")?;83		let value = value.try_into().map_err(|_| "value too long")?;8485		let nesting_budget = self86			.recorder87			.weight_calls_budget(<StructureWeight<T>>::find_parent());8889		<Pallet<T>>::set_token_property(90			self,91			&caller,92			TokenId(token_id),93			Property { key, value },94			&nesting_budget,95		)96		.map_err(dispatch_to_evm::<T>)97	}9899	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> 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")?;105106		let nesting_budget = self107			.recorder108			.weight_calls_budget(<StructureWeight<T>>::find_parent());109110		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)111			.map_err(dispatch_to_evm::<T>)112	}113114	/// Throws error if key not found115	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {116		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;117		let key = <Vec<u8>>::from(key)118			.try_into()119			.map_err(|_| "key too long")?;120121		let props = <TokenProperties<T>>::get((self.id, token_id));122		let prop = props.get(&key).ok_or("key not found")?;123124		Ok(prop.to_vec())125	}126}127128#[derive(ToLog)]129pub enum ERC721Events {130	Transfer {131		#[indexed]132		from: address,133		#[indexed]134		to: address,135		#[indexed]136		token_id: uint256,137	},138	Approval {139		#[indexed]140		owner: address,141		#[indexed]142		approved: address,143		#[indexed]144		token_id: uint256,145	},146	#[allow(dead_code)]147	ApprovalForAll {148		#[indexed]149		owner: address,150		#[indexed]151		operator: address,152		approved: bool,153	},154}155156#[derive(ToLog)]157pub enum ERC721MintableEvents {158	#[allow(dead_code)]159	MintingFinished {},160}161162#[solidity_interface(name = "ERC721Metadata")]163impl<T: Config> NonfungibleHandle<T> {164	fn name(&self) -> Result<string> {165		Ok(decode_utf16(self.name.iter().copied())166			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))167			.collect::<string>())168	}169170	fn symbol(&self) -> Result<string> {171		Ok(string::from_utf8_lossy(&self.token_prefix).into())172	}173174	/// Returns token's const_metadata175	#[solidity(rename_selector = "tokenURI")]176	fn token_uri(&self, token_id: uint256) -> Result<string> {177		let key = token_uri_key();178		if !has_token_permission::<T>(self.id, &key) {179			return Err("No tokenURI permission".into());180		}181182		self.consume_store_reads(1)?;183		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;184185		let properties = <TokenProperties<T>>::try_get((self.id, token_id))186			.map_err(|_| Error::Revert("Token properties not found".into()))?;187		if let Some(property) = properties.get(&key) {188			return Ok(string::from_utf8_lossy(property).into());189		}190191		Err("Property tokenURI not found".into())192	}193}194195#[solidity_interface(name = "ERC721Enumerable")]196impl<T: Config> NonfungibleHandle<T> {197	fn token_by_index(&self, index: uint256) -> Result<uint256> {198		Ok(index)199	}200201	/// Not implemented202	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {203		// TODO: Not implemetable204		Err("not implemented".into())205	}206207	fn total_supply(&self) -> Result<uint256> {208		self.consume_store_reads(1)?;209		Ok(<Pallet<T>>::total_supply(self).into())210	}211}212213#[solidity_interface(name = "ERC721", events(ERC721Events))]214impl<T: Config> NonfungibleHandle<T> {215	fn balance_of(&self, owner: address) -> Result<uint256> {216		self.consume_store_reads(1)?;217		let owner = T::CrossAccountId::from_eth(owner);218		let balance = <AccountBalance<T>>::get((self.id, owner));219		Ok(balance.into())220	}221	fn owner_of(&self, token_id: uint256) -> Result<address> {222		self.consume_store_reads(1)?;223		let token: TokenId = token_id.try_into()?;224		Ok(*<TokenData<T>>::get((self.id, token))225			.ok_or("token not found")?226			.owner227			.as_eth())228	}229	/// Not implemented230	fn safe_transfer_from_with_data(231		&mut self,232		_from: address,233		_to: address,234		_token_id: uint256,235		_data: bytes,236		_value: value,237	) -> Result<void> {238		// TODO: Not implemetable239		Err("not implemented".into())240	}241	/// Not implemented242	fn safe_transfer_from(243		&mut self,244		_from: address,245		_to: address,246		_token_id: uint256,247		_value: value,248	) -> Result<void> {249		// TODO: Not implemetable250		Err("not implemented".into())251	}252253	#[weight(<SelfWeightOf<T>>::transfer_from())]254	fn transfer_from(255		&mut self,256		caller: caller,257		from: address,258		to: address,259		token_id: uint256,260		_value: value,261	) -> Result<void> {262		let caller = T::CrossAccountId::from_eth(caller);263		let from = T::CrossAccountId::from_eth(from);264		let to = T::CrossAccountId::from_eth(to);265		let token = token_id.try_into()?;266		let budget = self267			.recorder268			.weight_calls_budget(<StructureWeight<T>>::find_parent());269270		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)271			.map_err(dispatch_to_evm::<T>)?;272		Ok(())273	}274275	#[weight(<SelfWeightOf<T>>::approve())]276	fn approve(277		&mut self,278		caller: caller,279		approved: address,280		token_id: uint256,281		_value: value,282	) -> Result<void> {283		let caller = T::CrossAccountId::from_eth(caller);284		let approved = T::CrossAccountId::from_eth(approved);285		let token = token_id.try_into()?;286287		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))288			.map_err(dispatch_to_evm::<T>)?;289		Ok(())290	}291292	/// Not implemented293	fn set_approval_for_all(294		&mut self,295		_caller: caller,296		_operator: address,297		_approved: bool,298	) -> Result<void> {299		// TODO: Not implemetable300		Err("not implemented".into())301	}302303	/// Not implemented304	fn get_approved(&self, _token_id: uint256) -> Result<address> {305		// TODO: Not implemetable306		Err("not implemented".into())307	}308309	/// Not implemented310	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {311		// TODO: Not implemetable312		Err("not implemented".into())313	}314}315316#[solidity_interface(name = "ERC721Burnable")]317impl<T: Config> NonfungibleHandle<T> {318	#[weight(<SelfWeightOf<T>>::burn_item())]319	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {320		let caller = T::CrossAccountId::from_eth(caller);321		let token = token_id.try_into()?;322323		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;324		Ok(())325	}326}327328#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]329impl<T: Config> NonfungibleHandle<T> {330	fn minting_finished(&self) -> Result<bool> {331		Ok(false)332	}333334	/// `token_id` should be obtained with `next_token_id` method,335	/// unlike standard, you can't specify it manually336	#[weight(<SelfWeightOf<T>>::create_item())]337	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {338		let caller = T::CrossAccountId::from_eth(caller);339		let to = T::CrossAccountId::from_eth(to);340		let token_id: u32 = token_id.try_into()?;341		let budget = self342			.recorder343			.weight_calls_budget(<StructureWeight<T>>::find_parent());344345		if <TokensMinted<T>>::get(self.id)346			.checked_add(1)347			.ok_or("item id overflow")?348			!= token_id349		{350			return Err("item id should be next".into());351		}352353		<Pallet<T>>::create_item(354			self,355			&caller,356			CreateItemData::<T> {357				properties: BoundedVec::default(),358				owner: to,359			},360			&budget,361		)362		.map_err(dispatch_to_evm::<T>)?;363364		Ok(true)365	}366367	/// `token_id` should be obtained with `next_token_id` method,368	/// unlike standard, you can't specify it manually369	#[solidity(rename_selector = "mintWithTokenURI")]370	#[weight(<SelfWeightOf<T>>::create_item())]371	fn mint_with_token_uri(372		&mut self,373		caller: caller,374		to: address,375		token_id: uint256,376		token_uri: string,377	) -> Result<bool> {378		let key = token_uri_key();379		let permission = get_token_permission::<T>(self.id, &key)?;380		if !permission.collection_admin {381			return Err("Operation is not allowed".into());382		}383384		let caller = T::CrossAccountId::from_eth(caller);385		let to = T::CrossAccountId::from_eth(to);386		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;387		let budget = self388			.recorder389			.weight_calls_budget(<StructureWeight<T>>::find_parent());390391		if <TokensMinted<T>>::get(self.id)392			.checked_add(1)393			.ok_or("item id overflow")?394			!= token_id395		{396			return Err("item id should be next".into());397		}398399		let mut properties = CollectionPropertiesVec::default();400		properties401			.try_push(Property {402				key,403				value: token_uri404					.into_bytes()405					.try_into()406					.map_err(|_| "token uri is too long")?,407			})408			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;409410		<Pallet<T>>::create_item(411			self,412			&caller,413			CreateItemData::<T> {414				properties,415				owner: to,416			},417			&budget,418		)419		.map_err(dispatch_to_evm::<T>)?;420		Ok(true)421	}422423	/// Not implemented424	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {425		Err("not implementable".into())426	}427}428429fn get_token_permission<T: Config>(430	collection_id: CollectionId,431	key: &PropertyKey,432) -> Result<PropertyPermission> {433	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)434		.map_err(|_| Error::Revert("No permissions for collection".into()))?;435	let a = token_property_permissions436		.get(key)437		.map(|p| p.clone())438		.ok_or_else(|| Error::Revert("No permission".into()))?;439	Ok(a)440}441442fn has_token_permission<T: Config>(collection_id: CollectionId, key: &PropertyKey) -> bool {443	if let Ok(token_property_permissions) =444		CollectionPropertyPermissions::<T>::try_get(collection_id)445	{446		return token_property_permissions.contains_key(key);447	}448449	false450}451452#[solidity_interface(name = "ERC721UniqueExtensions")]453impl<T: Config> NonfungibleHandle<T> {454	#[weight(<SelfWeightOf<T>>::transfer())]455	fn transfer(456		&mut self,457		caller: caller,458		to: address,459		token_id: uint256,460		_value: value,461	) -> Result<void> {462		let caller = T::CrossAccountId::from_eth(caller);463		let to = T::CrossAccountId::from_eth(to);464		let token = token_id.try_into()?;465		let budget = self466			.recorder467			.weight_calls_budget(<StructureWeight<T>>::find_parent());468469		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;470		Ok(())471	}472473	#[weight(<SelfWeightOf<T>>::burn_from())]474	fn burn_from(475		&mut self,476		caller: caller,477		from: address,478		token_id: uint256,479		_value: value,480	) -> Result<void> {481		let caller = T::CrossAccountId::from_eth(caller);482		let from = T::CrossAccountId::from_eth(from);483		let token = token_id.try_into()?;484		let budget = self485			.recorder486			.weight_calls_budget(<StructureWeight<T>>::find_parent());487488		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)489			.map_err(dispatch_to_evm::<T>)?;490		Ok(())491	}492493	fn next_token_id(&self) -> Result<uint256> {494		self.consume_store_reads(1)?;495		Ok(<TokensMinted<T>>::get(self.id)496			.checked_add(1)497			.ok_or("item id overflow")?498			.into())499	}500501	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]502	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {503		let caller = T::CrossAccountId::from_eth(caller);504		let to = T::CrossAccountId::from_eth(to);505		let mut expected_index = <TokensMinted<T>>::get(self.id)506			.checked_add(1)507			.ok_or("item id overflow")?;508		let budget = self509			.recorder510			.weight_calls_budget(<StructureWeight<T>>::find_parent());511512		let total_tokens = token_ids.len();513		for id in token_ids.into_iter() {514			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;515			if id != expected_index {516				return Err("item id should be next".into());517			}518			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;519		}520		let data = (0..total_tokens)521			.map(|_| CreateItemData::<T> {522				properties: BoundedVec::default(),523				owner: to.clone(),524			})525			.collect();526527		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)528			.map_err(dispatch_to_evm::<T>)?;529		Ok(true)530	}531532	#[solidity(rename_selector = "mintBulkWithTokenURI")]533	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]534	fn mint_bulk_with_token_uri(535		&mut self,536		caller: caller,537		to: address,538		tokens: Vec<(uint256, string)>,539	) -> Result<bool> {540		let key = token_uri_key();541		let caller = T::CrossAccountId::from_eth(caller);542		let to = T::CrossAccountId::from_eth(to);543		let mut expected_index = <TokensMinted<T>>::get(self.id)544			.checked_add(1)545			.ok_or("item id overflow")?;546		let budget = self547			.recorder548			.weight_calls_budget(<StructureWeight<T>>::find_parent());549550		let mut data = Vec::with_capacity(tokens.len());551		for (id, token_uri) in tokens {552			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;553			if id != expected_index {554				return Err("item id should be next".into());555			}556			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;557558			let mut properties = CollectionPropertiesVec::default();559			properties560				.try_push(Property {561					key: key.clone(),562					value: token_uri563						.into_bytes()564						.try_into()565						.map_err(|_| "token uri is too long")?,566				})567				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;568569			data.push(CreateItemData::<T> {570				properties,571				owner: to.clone(),572			});573		}574575		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)576			.map_err(dispatch_to_evm::<T>)?;577		Ok(true)578	}579}580581#[solidity_interface(582	name = "UniqueNFT",583	is(584		ERC721,585		ERC721Metadata,586		ERC721Enumerable,587		ERC721UniqueExtensions,588		ERC721Mintable,589		ERC721Burnable,590		via("CollectionHandle<T>", common_mut, Collection),591		TokenProperties,592	)593)]594impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> {}595596// Not a tests, but code generators597generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);598generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);599600impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>601where602	T::AccountId: From<[u8; 32]>,603{604	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");605606	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {607		call::<T, UniqueNFTCall<T>, _, _>(handle, self)608	}609}