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

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::{TokenId, SchemaVersion};25use pallet_evm_coder_substrate::dispatch_to_evm;26use sp_core::{H160, U256};27use sp_std::{vec::Vec, vec};28use pallet_common::{29	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},30	CollectionHandle,31};32use pallet_evm::account::CrossAccountId;33use pallet_evm_coder_substrate::call;34use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};3536use crate::{37	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,38	SelfWeightOf, weights::WeightInfo,39};4041fn error_unsupported_schema_version() -> Error {42	alloc::format!(43		"Unsupported schema version! Support only {:?}",44		SchemaVersion::ImageURL45	)46	.as_str()47	.into()48}4950#[derive(ToLog)]51pub enum ERC721Events {52	Transfer {53		#[indexed]54		from: address,55		#[indexed]56		to: address,57		#[indexed]58		token_id: uint256,59	},60	Approval {61		#[indexed]62		owner: address,63		#[indexed]64		approved: address,65		#[indexed]66		token_id: uint256,67	},68	#[allow(dead_code)]69	ApprovalForAll {70		#[indexed]71		owner: address,72		#[indexed]73		operator: address,74		approved: bool,75	},76}7778#[derive(ToLog)]79pub enum ERC721MintableEvents {80	#[allow(dead_code)]81	MintingFinished {},82}8384#[solidity_interface(name = "ERC721Metadata")]85impl<T: Config> NonfungibleHandle<T> {86	fn name(&self) -> Result<string> {87		Ok(decode_utf16(self.name.iter().copied())88			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))89			.collect::<string>())90	}9192	fn symbol(&self) -> Result<string> {93		Ok(string::from_utf8_lossy(&self.token_prefix).into())94	}9596	/// Returns token's const_metadata97	#[solidity(rename_selector = "tokenURI")]98	fn token_uri(&self, token_id: uint256) -> Result<string> {99		if !matches!(self.schema_version, SchemaVersion::ImageURL) {100			return Err(error_unsupported_schema_version());101		}102103		self.consume_store_reads(1)?;104		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;105		Ok(string::from_utf8_lossy(106			&<TokenData<T>>::get((self.id, token_id))107				.ok_or("token not found")?108				.const_data,109		)110		.into())111	}112}113114#[solidity_interface(name = "ERC721Enumerable")]115impl<T: Config> NonfungibleHandle<T> {116	fn token_by_index(&self, index: uint256) -> Result<uint256> {117		Ok(index)118	}119120	/// Not implemented121	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {122		// TODO: Not implemetable123		Err("not implemented".into())124	}125126	fn total_supply(&self) -> Result<uint256> {127		self.consume_store_reads(1)?;128		Ok(<Pallet<T>>::total_supply(self).into())129	}130}131132#[solidity_interface(name = "ERC721", events(ERC721Events))]133impl<T: Config> NonfungibleHandle<T> {134	fn balance_of(&self, owner: address) -> Result<uint256> {135		self.consume_store_reads(1)?;136		let owner = T::CrossAccountId::from_eth(owner);137		let balance = <AccountBalance<T>>::get((self.id, owner));138		Ok(balance.into())139	}140	fn owner_of(&self, token_id: uint256) -> Result<address> {141		self.consume_store_reads(1)?;142		let token: TokenId = token_id.try_into()?;143		Ok(*<TokenData<T>>::get((self.id, token))144			.ok_or("token not found")?145			.owner146			.as_eth())147	}148	/// Not implemented149	fn safe_transfer_from_with_data(150		&mut self,151		_from: address,152		_to: address,153		_token_id: uint256,154		_data: bytes,155		_value: value,156	) -> Result<void> {157		// TODO: Not implemetable158		Err("not implemented".into())159	}160	/// Not implemented161	fn safe_transfer_from(162		&mut self,163		_from: address,164		_to: address,165		_token_id: uint256,166		_value: value,167	) -> Result<void> {168		// TODO: Not implemetable169		Err("not implemented".into())170	}171172	#[weight(<SelfWeightOf<T>>::transfer_from())]173	fn transfer_from(174		&mut self,175		caller: caller,176		from: address,177		to: address,178		token_id: uint256,179		_value: value,180	) -> Result<void> {181		let caller = T::CrossAccountId::from_eth(caller);182		let from = T::CrossAccountId::from_eth(from);183		let to = T::CrossAccountId::from_eth(to);184		let token = token_id.try_into()?;185		let budget = self186			.recorder187			.weight_calls_budget(<StructureWeight<T>>::find_parent());188189		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)190			.map_err(dispatch_to_evm::<T>)?;191		Ok(())192	}193194	#[weight(<SelfWeightOf<T>>::approve())]195	fn approve(196		&mut self,197		caller: caller,198		approved: address,199		token_id: uint256,200		_value: value,201	) -> Result<void> {202		let caller = T::CrossAccountId::from_eth(caller);203		let approved = T::CrossAccountId::from_eth(approved);204		let token = token_id.try_into()?;205206		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))207			.map_err(dispatch_to_evm::<T>)?;208		Ok(())209	}210211	/// Not implemented212	fn set_approval_for_all(213		&mut self,214		_caller: caller,215		_operator: address,216		_approved: bool,217	) -> Result<void> {218		// TODO: Not implemetable219		Err("not implemented".into())220	}221222	/// Not implemented223	fn get_approved(&self, _token_id: uint256) -> Result<address> {224		// TODO: Not implemetable225		Err("not implemented".into())226	}227228	/// Not implemented229	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {230		// TODO: Not implemetable231		Err("not implemented".into())232	}233}234235#[solidity_interface(name = "ERC721Burnable")]236impl<T: Config> NonfungibleHandle<T> {237	#[weight(<SelfWeightOf<T>>::burn_item())]238	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {239		let caller = T::CrossAccountId::from_eth(caller);240		let token = token_id.try_into()?;241242		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;243		Ok(())244	}245}246247#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]248impl<T: Config> NonfungibleHandle<T> {249	fn minting_finished(&self) -> Result<bool> {250		Ok(false)251	}252253	/// `token_id` should be obtained with `next_token_id` method,254	/// unlike standard, you can't specify it manually255	#[weight(<SelfWeightOf<T>>::create_item())]256	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {257		let caller = T::CrossAccountId::from_eth(caller);258		let to = T::CrossAccountId::from_eth(to);259		let token_id: u32 = token_id.try_into()?;260		let budget = self261			.recorder262			.weight_calls_budget(<StructureWeight<T>>::find_parent());263264		if <TokensMinted<T>>::get(self.id)265			.checked_add(1)266			.ok_or("item id overflow")?267			!= token_id268		{269			return Err("item id should be next".into());270		}271272		<Pallet<T>>::create_item(273			self,274			&caller,275			CreateItemData::<T> {276				const_data: BoundedVec::default(),277				variable_data: BoundedVec::default(),278				properties: BoundedVec::default(),279				owner: to,280			},281			&budget,282		)283		.map_err(dispatch_to_evm::<T>)?;284285		Ok(true)286	}287288	/// `token_id` should be obtained with `next_token_id` method,289	/// unlike standard, you can't specify it manually290	#[solidity(rename_selector = "mintWithTokenURI")]291	#[weight(<SelfWeightOf<T>>::create_item())]292	fn mint_with_token_uri(293		&mut self,294		caller: caller,295		to: address,296		token_id: uint256,297		token_uri: string,298	) -> Result<bool> {299		if !matches!(self.schema_version, SchemaVersion::ImageURL) {300			return Err(error_unsupported_schema_version());301		}302303		let caller = T::CrossAccountId::from_eth(caller);304		let to = T::CrossAccountId::from_eth(to);305		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;306		let budget = self307			.recorder308			.weight_calls_budget(<StructureWeight<T>>::find_parent());309310		if <TokensMinted<T>>::get(self.id)311			.checked_add(1)312			.ok_or("item id overflow")?313			!= token_id314		{315			return Err("item id should be next".into());316		}317318		<Pallet<T>>::create_item(319			self,320			&caller,321			CreateItemData::<T> {322				const_data: Vec::<u8>::from(token_uri)323					.try_into()324					.map_err(|_| "token uri is too long")?,325				variable_data: BoundedVec::default(),326				properties: BoundedVec::default(),327				owner: to,328			},329			&budget,330		)331		.map_err(dispatch_to_evm::<T>)?;332		Ok(true)333	}334335	/// Not implemented336	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {337		Err("not implementable".into())338	}339}340341#[solidity_interface(name = "ERC721UniqueExtensions")]342impl<T: Config> NonfungibleHandle<T> {343	#[weight(<SelfWeightOf<T>>::transfer())]344	fn transfer(345		&mut self,346		caller: caller,347		to: address,348		token_id: uint256,349		_value: value,350	) -> Result<void> {351		let caller = T::CrossAccountId::from_eth(caller);352		let to = T::CrossAccountId::from_eth(to);353		let token = token_id.try_into()?;354		let budget = self355			.recorder356			.weight_calls_budget(<StructureWeight<T>>::find_parent());357358		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;359		Ok(())360	}361362	#[weight(<SelfWeightOf<T>>::burn_from())]363	fn burn_from(364		&mut self,365		caller: caller,366		from: address,367		token_id: uint256,368		_value: value,369	) -> Result<void> {370		let caller = T::CrossAccountId::from_eth(caller);371		let from = T::CrossAccountId::from_eth(from);372		let token = token_id.try_into()?;373		let budget = self374			.recorder375			.weight_calls_budget(<StructureWeight<T>>::find_parent());376377		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)378			.map_err(dispatch_to_evm::<T>)?;379		Ok(())380	}381382	fn next_token_id(&self) -> Result<uint256> {383		self.consume_store_reads(1)?;384		Ok(<TokensMinted<T>>::get(self.id)385			.checked_add(1)386			.ok_or("item id overflow")?387			.into())388	}389390	#[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]391	fn set_variable_metadata(392		&mut self,393		caller: caller,394		token_id: uint256,395		data: bytes,396	) -> Result<void> {397		let caller = T::CrossAccountId::from_eth(caller);398		let token = token_id.try_into()?;399400		<Pallet<T>>::set_variable_metadata(401			self,402			&caller,403			token,404			data.try_into()405				.map_err(|_| "metadata size exceeded limit")?,406		)407		.map_err(dispatch_to_evm::<T>)?;408		Ok(())409	}410411	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {412		self.consume_store_reads(1)?;413		let token: TokenId = token_id.try_into()?;414415		Ok(<TokenData<T>>::get((self.id, token))416			.ok_or("token not found")?417			.variable_data418			.into_inner())419	}420421	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]422	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {423		let caller = T::CrossAccountId::from_eth(caller);424		let to = T::CrossAccountId::from_eth(to);425		let mut expected_index = <TokensMinted<T>>::get(self.id)426			.checked_add(1)427			.ok_or("item id overflow")?;428		let budget = self429			.recorder430			.weight_calls_budget(<StructureWeight<T>>::find_parent());431432		let total_tokens = token_ids.len();433		for id in token_ids.into_iter() {434			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;435			if id != expected_index {436				return Err("item id should be next".into());437			}438			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;439		}440		let data = (0..total_tokens)441			.map(|_| CreateItemData::<T> {442				const_data: BoundedVec::default(),443				variable_data: BoundedVec::default(),444				properties: BoundedVec::default(),445				owner: to.clone(),446			})447			.collect();448449		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)450			.map_err(dispatch_to_evm::<T>)?;451		Ok(true)452	}453454	#[solidity(rename_selector = "mintBulkWithTokenURI")]455	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]456	fn mint_bulk_with_token_uri(457		&mut self,458		caller: caller,459		to: address,460		tokens: Vec<(uint256, string)>,461	) -> Result<bool> {462		if !matches!(self.schema_version, SchemaVersion::ImageURL) {463			return Err(error_unsupported_schema_version());464		}465466		let caller = T::CrossAccountId::from_eth(caller);467		let to = T::CrossAccountId::from_eth(to);468		let mut expected_index = <TokensMinted<T>>::get(self.id)469			.checked_add(1)470			.ok_or("item id overflow")?;471		let budget = self472			.recorder473			.weight_calls_budget(<StructureWeight<T>>::find_parent());474475		let mut data = Vec::with_capacity(tokens.len());476		for (id, token_uri) in tokens {477			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;478			if id != expected_index {479				return Err("item id should be next".into());480			}481			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;482483			data.push(CreateItemData::<T> {484				const_data: Vec::<u8>::from(token_uri)485					.try_into()486					.map_err(|_| "token uri is too long")?,487				variable_data: vec![].try_into().unwrap(),488				properties: BoundedVec::default(),489				owner: to.clone(),490			});491		}492493		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)494			.map_err(dispatch_to_evm::<T>)?;495		Ok(true)496	}497}498499#[solidity_interface(500	name = "UniqueNFT",501	is(502		ERC721,503		ERC721Metadata,504		ERC721Enumerable,505		ERC721UniqueExtensions,506		ERC721Mintable,507		ERC721Burnable,508		via("CollectionHandle<T>", common_mut, CollectionProperties)509	)510)]511impl<T: Config> NonfungibleHandle<T> {}512513// Not a tests, but code generators514generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);515generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);516517impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {518	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");519520	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult> {521		call::<T, UniqueNFTCall<T>, _>(*source, self, value, input)522	}523}