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

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},30};31use pallet_evm::account::CrossAccountId;32use pallet_evm_coder_substrate::call;33use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};3435use crate::{36	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,37	SelfWeightOf, weights::WeightInfo,38};3940fn error_unsupported_schema_version() -> Error {41	alloc::format!(42		"Unsupported schema version! Support only {:?}",43		SchemaVersion::ImageURL44	)45	.as_str()46	.into()47}4849#[derive(ToLog)]50pub enum ERC721Events {51	Transfer {52		#[indexed]53		from: address,54		#[indexed]55		to: address,56		#[indexed]57		token_id: uint256,58	},59	Approval {60		#[indexed]61		owner: address,62		#[indexed]63		approved: address,64		#[indexed]65		token_id: uint256,66	},67	#[allow(dead_code)]68	ApprovalForAll {69		#[indexed]70		owner: address,71		#[indexed]72		operator: address,73		approved: bool,74	},75}7677#[derive(ToLog)]78pub enum ERC721MintableEvents {79	#[allow(dead_code)]80	MintingFinished {},81}8283#[solidity_interface(name = "ERC721Metadata")]84impl<T: Config> NonfungibleHandle<T> {85	fn name(&self) -> Result<string> {86		Ok(decode_utf16(self.name.iter().copied())87			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))88			.collect::<string>())89	}9091	fn symbol(&self) -> Result<string> {92		Ok(string::from_utf8_lossy(&self.token_prefix).into())93	}9495	/// Returns token's const_metadata96	#[solidity(rename_selector = "tokenURI")]97	fn token_uri(&self, token_id: uint256) -> Result<string> {98		if !matches!(self.schema_version, SchemaVersion::ImageURL) {99			return Err(error_unsupported_schema_version());100		}101102		self.consume_store_reads(1)?;103		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;104		Ok(string::from_utf8_lossy(105			&<TokenData<T>>::get((self.id, token_id))106				.ok_or("token not found")?107				.const_data,108		)109		.into())110	}111}112113#[solidity_interface(name = "ERC721Enumerable")]114impl<T: Config> NonfungibleHandle<T> {115	fn token_by_index(&self, index: uint256) -> Result<uint256> {116		Ok(index)117	}118119	/// Not implemented120	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {121		// TODO: Not implemetable122		Err("not implemented".into())123	}124125	fn total_supply(&self) -> Result<uint256> {126		self.consume_store_reads(1)?;127		Ok(<Pallet<T>>::total_supply(self).into())128	}129}130131#[solidity_interface(name = "ERC721", events(ERC721Events))]132impl<T: Config> NonfungibleHandle<T> {133	fn balance_of(&self, owner: address) -> Result<uint256> {134		self.consume_store_reads(1)?;135		let owner = T::CrossAccountId::from_eth(owner);136		let balance = <AccountBalance<T>>::get((self.id, owner));137		Ok(balance.into())138	}139	fn owner_of(&self, token_id: uint256) -> Result<address> {140		self.consume_store_reads(1)?;141		let token: TokenId = token_id.try_into()?;142		Ok(*<TokenData<T>>::get((self.id, token))143			.ok_or("token not found")?144			.owner145			.as_eth())146	}147	/// Not implemented148	fn safe_transfer_from_with_data(149		&mut self,150		_from: address,151		_to: address,152		_token_id: uint256,153		_data: bytes,154		_value: value,155	) -> Result<void> {156		// TODO: Not implemetable157		Err("not implemented".into())158	}159	/// Not implemented160	fn safe_transfer_from(161		&mut self,162		_from: address,163		_to: address,164		_token_id: uint256,165		_value: value,166	) -> Result<void> {167		// TODO: Not implemetable168		Err("not implemented".into())169	}170171	#[weight(<SelfWeightOf<T>>::transfer_from())]172	fn transfer_from(173		&mut self,174		caller: caller,175		from: address,176		to: address,177		token_id: uint256,178		_value: value,179	) -> Result<void> {180		let caller = T::CrossAccountId::from_eth(caller);181		let from = T::CrossAccountId::from_eth(from);182		let to = T::CrossAccountId::from_eth(to);183		let token = token_id.try_into()?;184		let budget = self185			.recorder186			.weight_calls_budget(<StructureWeight<T>>::find_parent());187188		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)189			.map_err(dispatch_to_evm::<T>)?;190		Ok(())191	}192193	#[weight(<SelfWeightOf<T>>::approve())]194	fn approve(195		&mut self,196		caller: caller,197		approved: address,198		token_id: uint256,199		_value: value,200	) -> Result<void> {201		let caller = T::CrossAccountId::from_eth(caller);202		let approved = T::CrossAccountId::from_eth(approved);203		let token = token_id.try_into()?;204205		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))206			.map_err(dispatch_to_evm::<T>)?;207		Ok(())208	}209210	/// Not implemented211	fn set_approval_for_all(212		&mut self,213		_caller: caller,214		_operator: address,215		_approved: bool,216	) -> Result<void> {217		// TODO: Not implemetable218		Err("not implemented".into())219	}220221	/// Not implemented222	fn get_approved(&self, _token_id: uint256) -> Result<address> {223		// TODO: Not implemetable224		Err("not implemented".into())225	}226227	/// Not implemented228	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {229		// TODO: Not implemetable230		Err("not implemented".into())231	}232}233234#[solidity_interface(name = "ERC721Burnable")]235impl<T: Config> NonfungibleHandle<T> {236	#[weight(<SelfWeightOf<T>>::burn_item())]237	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {238		let caller = T::CrossAccountId::from_eth(caller);239		let token = token_id.try_into()?;240241		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;242		Ok(())243	}244}245246#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]247impl<T: Config> NonfungibleHandle<T> {248	fn minting_finished(&self) -> Result<bool> {249		Ok(false)250	}251252	/// `token_id` should be obtained with `next_token_id` method,253	/// unlike standard, you can't specify it manually254	#[weight(<SelfWeightOf<T>>::create_item())]255	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {256		let caller = T::CrossAccountId::from_eth(caller);257		let to = T::CrossAccountId::from_eth(to);258		let token_id: u32 = token_id.try_into()?;259		let budget = self260			.recorder261			.weight_calls_budget(<StructureWeight<T>>::find_parent());262263		if <TokensMinted<T>>::get(self.id)264			.checked_add(1)265			.ok_or("item id overflow")?266			!= token_id267		{268			return Err("item id should be next".into());269		}270271		<Pallet<T>>::create_item(272			self,273			&caller,274			CreateItemData::<T> {275				const_data: BoundedVec::default(),276				variable_data: BoundedVec::default(),277				owner: to,278			},279			&budget,280		)281		.map_err(dispatch_to_evm::<T>)?;282283		Ok(true)284	}285286	/// `token_id` should be obtained with `next_token_id` method,287	/// unlike standard, you can't specify it manually288	#[solidity(rename_selector = "mintWithTokenURI")]289	#[weight(<SelfWeightOf<T>>::create_item())]290	fn mint_with_token_uri(291		&mut self,292		caller: caller,293		to: address,294		token_id: uint256,295		token_uri: string,296	) -> Result<bool> {297		if !matches!(self.schema_version, SchemaVersion::ImageURL) {298			return Err(error_unsupported_schema_version());299		}300301		let caller = T::CrossAccountId::from_eth(caller);302		let to = T::CrossAccountId::from_eth(to);303		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;304		let budget = self305			.recorder306			.weight_calls_budget(<StructureWeight<T>>::find_parent());307308		if <TokensMinted<T>>::get(self.id)309			.checked_add(1)310			.ok_or("item id overflow")?311			!= token_id312		{313			return Err("item id should be next".into());314		}315316		<Pallet<T>>::create_item(317			self,318			&caller,319			CreateItemData::<T> {320				const_data: Vec::<u8>::from(token_uri)321					.try_into()322					.map_err(|_| "token uri is too long")?,323				variable_data: BoundedVec::default(),324				owner: to,325			},326			&budget,327		)328		.map_err(dispatch_to_evm::<T>)?;329		Ok(true)330	}331332	/// Not implemented333	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {334		Err("not implementable".into())335	}336}337338#[solidity_interface(name = "ERC721UniqueExtensions")]339impl<T: Config> NonfungibleHandle<T> {340	#[weight(<SelfWeightOf<T>>::transfer())]341	fn transfer(342		&mut self,343		caller: caller,344		to: address,345		token_id: uint256,346		_value: value,347	) -> Result<void> {348		let caller = T::CrossAccountId::from_eth(caller);349		let to = T::CrossAccountId::from_eth(to);350		let token = token_id.try_into()?;351		let budget = self352			.recorder353			.weight_calls_budget(<StructureWeight<T>>::find_parent());354355		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;356		Ok(())357	}358359	#[weight(<SelfWeightOf<T>>::burn_from())]360	fn burn_from(361		&mut self,362		caller: caller,363		from: address,364		token_id: uint256,365		_value: value,366	) -> Result<void> {367		let caller = T::CrossAccountId::from_eth(caller);368		let from = T::CrossAccountId::from_eth(from);369		let token = token_id.try_into()?;370		let budget = self371			.recorder372			.weight_calls_budget(<StructureWeight<T>>::find_parent());373374		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)375			.map_err(dispatch_to_evm::<T>)?;376		Ok(())377	}378379	fn next_token_id(&self) -> Result<uint256> {380		self.consume_store_reads(1)?;381		Ok(<TokensMinted<T>>::get(self.id)382			.checked_add(1)383			.ok_or("item id overflow")?384			.into())385	}386387	#[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]388	fn set_variable_metadata(389		&mut self,390		caller: caller,391		token_id: uint256,392		data: bytes,393	) -> Result<void> {394		let caller = T::CrossAccountId::from_eth(caller);395		let token = token_id.try_into()?;396397		<Pallet<T>>::set_variable_metadata(398			self,399			&caller,400			token,401			data.try_into()402				.map_err(|_| "metadata size exceeded limit")?,403		)404		.map_err(dispatch_to_evm::<T>)?;405		Ok(())406	}407408	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {409		self.consume_store_reads(1)?;410		let token: TokenId = token_id.try_into()?;411412		Ok(<TokenData<T>>::get((self.id, token))413			.ok_or("token not found")?414			.variable_data415			.into_inner())416	}417418	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]419	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {420		let caller = T::CrossAccountId::from_eth(caller);421		let to = T::CrossAccountId::from_eth(to);422		let mut expected_index = <TokensMinted<T>>::get(self.id)423			.checked_add(1)424			.ok_or("item id overflow")?;425		let budget = self426			.recorder427			.weight_calls_budget(<StructureWeight<T>>::find_parent());428429		let total_tokens = token_ids.len();430		for id in token_ids.into_iter() {431			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;432			if id != expected_index {433				return Err("item id should be next".into());434			}435			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;436		}437		let data = (0..total_tokens)438			.map(|_| CreateItemData::<T> {439				const_data: BoundedVec::default(),440				variable_data: BoundedVec::default(),441				owner: to.clone(),442			})443			.collect();444445		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)446			.map_err(dispatch_to_evm::<T>)?;447		Ok(true)448	}449450	#[solidity(rename_selector = "mintBulkWithTokenURI")]451	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]452	fn mint_bulk_with_token_uri(453		&mut self,454		caller: caller,455		to: address,456		tokens: Vec<(uint256, string)>,457	) -> Result<bool> {458		if !matches!(self.schema_version, SchemaVersion::ImageURL) {459			return Err(error_unsupported_schema_version());460		}461462		let caller = T::CrossAccountId::from_eth(caller);463		let to = T::CrossAccountId::from_eth(to);464		let mut expected_index = <TokensMinted<T>>::get(self.id)465			.checked_add(1)466			.ok_or("item id overflow")?;467		let budget = self468			.recorder469			.weight_calls_budget(<StructureWeight<T>>::find_parent());470471		let mut data = Vec::with_capacity(tokens.len());472		for (id, token_uri) in tokens {473			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;474			if id != expected_index {475				return Err("item id should be next".into());476			}477			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;478479			data.push(CreateItemData::<T> {480				const_data: Vec::<u8>::from(token_uri)481					.try_into()482					.map_err(|_| "token uri is too long")?,483				variable_data: vec![].try_into().unwrap(),484				owner: to.clone(),485			});486		}487488		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)489			.map_err(dispatch_to_evm::<T>)?;490		Ok(true)491	}492}493494#[solidity_interface(495	name = "UniqueNFT",496	is(497		ERC721,498		ERC721Metadata,499		ERC721Enumerable,500		ERC721UniqueExtensions,501		ERC721Mintable,502		ERC721Burnable,503	)504)]505impl<T: Config> NonfungibleHandle<T> {}506507// Not a tests, but code generators508generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);509generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);510511impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {512	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");513514	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult> {515		call::<T, UniqueNFTCall<T>, _>(*source, self, value, input)516	}517}