git.delta.rocks / unique-network / refs/commits / 6020bb04e7f4

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;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				properties: BoundedVec::default(),278				owner: to,279			},280			&budget,281		)282		.map_err(dispatch_to_evm::<T>)?;283284		Ok(true)285	}286287	/// `token_id` should be obtained with `next_token_id` method,288	/// unlike standard, you can't specify it manually289	#[solidity(rename_selector = "mintWithTokenURI")]290	#[weight(<SelfWeightOf<T>>::create_item())]291	fn mint_with_token_uri(292		&mut self,293		caller: caller,294		to: address,295		token_id: uint256,296		token_uri: string,297	) -> Result<bool> {298		if !matches!(self.schema_version, SchemaVersion::ImageURL) {299			return Err(error_unsupported_schema_version());300		}301302		let caller = T::CrossAccountId::from_eth(caller);303		let to = T::CrossAccountId::from_eth(to);304		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;305		let budget = self306			.recorder307			.weight_calls_budget(<StructureWeight<T>>::find_parent());308309		if <TokensMinted<T>>::get(self.id)310			.checked_add(1)311			.ok_or("item id overflow")?312			!= token_id313		{314			return Err("item id should be next".into());315		}316317		<Pallet<T>>::create_item(318			self,319			&caller,320			CreateItemData::<T> {321				const_data: Vec::<u8>::from(token_uri)322					.try_into()323					.map_err(|_| "token uri is too long")?,324				properties: BoundedVec::default(),325				owner: to,326			},327			&budget,328		)329		.map_err(dispatch_to_evm::<T>)?;330		Ok(true)331	}332333	/// Not implemented334	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {335		Err("not implementable".into())336	}337}338339#[solidity_interface(name = "ERC721UniqueExtensions")]340impl<T: Config> NonfungibleHandle<T> {341	#[weight(<SelfWeightOf<T>>::transfer())]342	fn transfer(343		&mut self,344		caller: caller,345		to: address,346		token_id: uint256,347		_value: value,348	) -> Result<void> {349		let caller = T::CrossAccountId::from_eth(caller);350		let to = T::CrossAccountId::from_eth(to);351		let token = token_id.try_into()?;352		let budget = self353			.recorder354			.weight_calls_budget(<StructureWeight<T>>::find_parent());355356		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;357		Ok(())358	}359360	#[weight(<SelfWeightOf<T>>::burn_from())]361	fn burn_from(362		&mut self,363		caller: caller,364		from: address,365		token_id: uint256,366		_value: value,367	) -> Result<void> {368		let caller = T::CrossAccountId::from_eth(caller);369		let from = T::CrossAccountId::from_eth(from);370		let token = token_id.try_into()?;371		let budget = self372			.recorder373			.weight_calls_budget(<StructureWeight<T>>::find_parent());374375		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)376			.map_err(dispatch_to_evm::<T>)?;377		Ok(())378	}379380	fn next_token_id(&self) -> Result<uint256> {381		self.consume_store_reads(1)?;382		Ok(<TokensMinted<T>>::get(self.id)383			.checked_add(1)384			.ok_or("item id overflow")?385			.into())386	}387388	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]389	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {390		let caller = T::CrossAccountId::from_eth(caller);391		let to = T::CrossAccountId::from_eth(to);392		let mut expected_index = <TokensMinted<T>>::get(self.id)393			.checked_add(1)394			.ok_or("item id overflow")?;395		let budget = self396			.recorder397			.weight_calls_budget(<StructureWeight<T>>::find_parent());398399		let total_tokens = token_ids.len();400		for id in token_ids.into_iter() {401			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;402			if id != expected_index {403				return Err("item id should be next".into());404			}405			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;406		}407		let data = (0..total_tokens)408			.map(|_| CreateItemData::<T> {409				const_data: BoundedVec::default(),410				properties: BoundedVec::default(),411				owner: to.clone(),412			})413			.collect();414415		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)416			.map_err(dispatch_to_evm::<T>)?;417		Ok(true)418	}419420	#[solidity(rename_selector = "mintBulkWithTokenURI")]421	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]422	fn mint_bulk_with_token_uri(423		&mut self,424		caller: caller,425		to: address,426		tokens: Vec<(uint256, string)>,427	) -> Result<bool> {428		if !matches!(self.schema_version, SchemaVersion::ImageURL) {429			return Err(error_unsupported_schema_version());430		}431432		let caller = T::CrossAccountId::from_eth(caller);433		let to = T::CrossAccountId::from_eth(to);434		let mut expected_index = <TokensMinted<T>>::get(self.id)435			.checked_add(1)436			.ok_or("item id overflow")?;437		let budget = self438			.recorder439			.weight_calls_budget(<StructureWeight<T>>::find_parent());440441		let mut data = Vec::with_capacity(tokens.len());442		for (id, token_uri) in tokens {443			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;444			if id != expected_index {445				return Err("item id should be next".into());446			}447			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;448449			data.push(CreateItemData::<T> {450				const_data: Vec::<u8>::from(token_uri)451					.try_into()452					.map_err(|_| "token uri is too long")?,453				properties: BoundedVec::default(),454				owner: to.clone(),455			});456		}457458		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)459			.map_err(dispatch_to_evm::<T>)?;460		Ok(true)461	}462}463464#[solidity_interface(465	name = "UniqueNFT",466	is(467		ERC721,468		ERC721Metadata,469		ERC721Enumerable,470		ERC721UniqueExtensions,471		ERC721Mintable,472		ERC721Burnable,473		via("CollectionHandle<T>", common_mut, CollectionProperties)474	)475)]476impl<T: Config> NonfungibleHandle<T> {}477478// Not a tests, but code generators479generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);480generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);481482impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {483	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");484485	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult> {486		call::<T, UniqueNFTCall<T>, _>(*source, self, value, input)487	}488}