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

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/>.1617use core::{18	char::{REPLACEMENT_CHARACTER, decode_utf16},19	convert::TryInto,20};21use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};22use frame_support::BoundedVec;23use up_data_structs::TokenId;24use pallet_evm_coder_substrate::dispatch_to_evm;25use sp_core::{H160, U256};26use sp_std::{vec::Vec, vec};27use pallet_common::{28	account::CrossAccountId,29	erc::{CommonEvmHandler, PrecompileResult},30};31use pallet_evm_coder_substrate::call;3233use crate::{34	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,35	SelfWeightOf, weights::WeightInfo,36};3738#[derive(ToLog)]39pub enum ERC721Events {40	Transfer {41		#[indexed]42		from: address,43		#[indexed]44		to: address,45		#[indexed]46		token_id: uint256,47	},48	Approval {49		#[indexed]50		owner: address,51		#[indexed]52		approved: address,53		#[indexed]54		token_id: uint256,55	},56	#[allow(dead_code)]57	ApprovalForAll {58		#[indexed]59		owner: address,60		#[indexed]61		operator: address,62		approved: bool,63	},64}6566#[derive(ToLog)]67pub enum ERC721MintableEvents {68	#[allow(dead_code)]69	MintingFinished {},70}7172#[solidity_interface(name = "ERC721Metadata")]73impl<T: Config> NonfungibleHandle<T> {74	fn name(&self) -> Result<string> {75		Ok(decode_utf16(self.name.iter().copied())76			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))77			.collect::<string>())78	}79	fn symbol(&self) -> Result<string> {80		Ok(string::from_utf8_lossy(&self.token_prefix).into())81	}8283	/// Returns token's const_metadata84	#[solidity(rename_selector = "tokenURI")]85	fn token_uri(&self, token_id: uint256) -> Result<string> {86		self.consume_store_reads(1)?;87		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;88		Ok(string::from_utf8_lossy(89			&<TokenData<T>>::get((self.id, token_id))90				.ok_or("token not found")?91				.const_data,92		)93		.into())94	}95}9697#[solidity_interface(name = "ERC721Enumerable")]98impl<T: Config> NonfungibleHandle<T> {99	fn token_by_index(&self, index: uint256) -> Result<uint256> {100		Ok(index)101	}102103	/// Not implemented104	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {105		// TODO: Not implemetable106		Err("not implemented".into())107	}108109	fn total_supply(&self) -> Result<uint256> {110		self.consume_store_reads(1)?;111		Ok(<Pallet<T>>::total_supply(self).into())112	}113}114115#[solidity_interface(name = "ERC721", events(ERC721Events))]116impl<T: Config> NonfungibleHandle<T> {117	fn balance_of(&self, owner: address) -> Result<uint256> {118		self.consume_store_reads(1)?;119		let owner = T::CrossAccountId::from_eth(owner);120		let balance = <AccountBalance<T>>::get((self.id, owner));121		Ok(balance.into())122	}123	fn owner_of(&self, token_id: uint256) -> Result<address> {124		self.consume_store_reads(1)?;125		let token: TokenId = token_id.try_into()?;126		Ok(*<TokenData<T>>::get((self.id, token))127			.ok_or("token not found")?128			.owner129			.as_eth())130	}131	/// Not implemented132	fn safe_transfer_from_with_data(133		&mut self,134		_from: address,135		_to: address,136		_token_id: uint256,137		_data: bytes,138		_value: value,139	) -> Result<void> {140		// TODO: Not implemetable141		Err("not implemented".into())142	}143	/// Not implemented144	fn safe_transfer_from(145		&mut self,146		_from: address,147		_to: address,148		_token_id: uint256,149		_value: value,150	) -> Result<void> {151		// TODO: Not implemetable152		Err("not implemented".into())153	}154155	#[weight(<SelfWeightOf<T>>::transfer_from())]156	fn transfer_from(157		&mut self,158		caller: caller,159		from: address,160		to: address,161		token_id: uint256,162		_value: value,163	) -> Result<void> {164		let caller = T::CrossAccountId::from_eth(caller);165		let from = T::CrossAccountId::from_eth(from);166		let to = T::CrossAccountId::from_eth(to);167		let token = token_id.try_into()?;168169		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token)170			.map_err(dispatch_to_evm::<T>)?;171		Ok(())172	}173174	#[weight(<SelfWeightOf<T>>::approve())]175	fn approve(176		&mut self,177		caller: caller,178		approved: address,179		token_id: uint256,180		_value: value,181	) -> Result<void> {182		let caller = T::CrossAccountId::from_eth(caller);183		let approved = T::CrossAccountId::from_eth(approved);184		let token = token_id.try_into()?;185186		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))187			.map_err(dispatch_to_evm::<T>)?;188		Ok(())189	}190191	/// Not implemented192	fn set_approval_for_all(193		&mut self,194		_caller: caller,195		_operator: address,196		_approved: bool,197	) -> Result<void> {198		// TODO: Not implemetable199		Err("not implemented".into())200	}201202	/// Not implemented203	fn get_approved(&self, _token_id: uint256) -> Result<address> {204		// TODO: Not implemetable205		Err("not implemented".into())206	}207208	/// Not implemented209	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {210		// TODO: Not implemetable211		Err("not implemented".into())212	}213}214215#[solidity_interface(name = "ERC721Burnable")]216impl<T: Config> NonfungibleHandle<T> {217	#[weight(<SelfWeightOf<T>>::burn_item())]218	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {219		let caller = T::CrossAccountId::from_eth(caller);220		let token = token_id.try_into()?;221222		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;223		Ok(())224	}225}226227#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]228impl<T: Config> NonfungibleHandle<T> {229	fn minting_finished(&self) -> Result<bool> {230		Ok(false)231	}232233	/// `token_id` should be obtained with `next_token_id` method,234	/// unlike standard, you can't specify it manually235	#[weight(<SelfWeightOf<T>>::create_item())]236	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {237		let caller = T::CrossAccountId::from_eth(caller);238		let to = T::CrossAccountId::from_eth(to);239		let token_id: u32 = token_id.try_into()?;240		if <TokensMinted<T>>::get(self.id)241			.checked_add(1)242			.ok_or("item id overflow")?243			!= token_id244		{245			return Err("item id should be next".into());246		}247248		<Pallet<T>>::create_item(249			self,250			&caller,251			CreateItemData::<T> {252				const_data: BoundedVec::default(),253				variable_data: BoundedVec::default(),254				owner: to,255			},256		)257		.map_err(dispatch_to_evm::<T>)?;258259		Ok(true)260	}261262	/// `token_id` should be obtained with `next_token_id` method,263	/// unlike standard, you can't specify it manually264	#[solidity(rename_selector = "mintWithTokenURI")]265	#[weight(<SelfWeightOf<T>>::create_item())]266	fn mint_with_token_uri(267		&mut self,268		caller: caller,269		to: address,270		token_id: uint256,271		token_uri: string,272	) -> Result<bool> {273		let caller = T::CrossAccountId::from_eth(caller);274		let to = T::CrossAccountId::from_eth(to);275		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;276		if <TokensMinted<T>>::get(self.id)277			.checked_add(1)278			.ok_or("item id overflow")?279			!= token_id280		{281			return Err("item id should be next".into());282		}283284		<Pallet<T>>::create_item(285			self,286			&caller,287			CreateItemData::<T> {288				const_data: Vec::<u8>::from(token_uri)289					.try_into()290					.map_err(|_| "token uri is too long")?,291				variable_data: BoundedVec::default(),292				owner: to,293			},294		)295		.map_err(dispatch_to_evm::<T>)?;296		Ok(true)297	}298299	/// Not implemented300	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {301		Err("not implementable".into())302	}303}304305#[solidity_interface(name = "ERC721UniqueExtensions")]306impl<T: Config> NonfungibleHandle<T> {307	#[weight(<SelfWeightOf<T>>::transfer())]308	fn transfer(309		&mut self,310		caller: caller,311		to: address,312		token_id: uint256,313		_value: value,314	) -> Result<void> {315		let caller = T::CrossAccountId::from_eth(caller);316		let to = T::CrossAccountId::from_eth(to);317		let token = token_id.try_into()?;318319		<Pallet<T>>::transfer(self, &caller, &to, token).map_err(dispatch_to_evm::<T>)?;320		Ok(())321	}322323	#[weight(<SelfWeightOf<T>>::burn_from())]324	fn burn_from(325		&mut self,326		caller: caller,327		from: address,328		token_id: uint256,329		_value: value,330	) -> Result<void> {331		let caller = T::CrossAccountId::from_eth(caller);332		let from = T::CrossAccountId::from_eth(from);333		let token = token_id.try_into()?;334335		<Pallet<T>>::burn_from(self, &caller, &from, token).map_err(dispatch_to_evm::<T>)?;336		Ok(())337	}338339	fn next_token_id(&self) -> Result<uint256> {340		self.consume_store_reads(1)?;341		Ok(<TokensMinted<T>>::get(self.id)342			.checked_add(1)343			.ok_or("item id overflow")?344			.into())345	}346347	#[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]348	fn set_variable_metadata(349		&mut self,350		caller: caller,351		token_id: uint256,352		data: bytes,353	) -> Result<void> {354		let caller = T::CrossAccountId::from_eth(caller);355		let token = token_id.try_into()?;356357		<Pallet<T>>::set_variable_metadata(358			self,359			&caller,360			token,361			data.try_into()362				.map_err(|_| "metadata size exceeded limit")?,363		)364		.map_err(dispatch_to_evm::<T>)?;365		Ok(())366	}367368	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {369		self.consume_store_reads(1)?;370		let token: TokenId = token_id.try_into()?;371372		Ok(<TokenData<T>>::get((self.id, token))373			.ok_or("token not found")?374			.variable_data375			.into_inner())376	}377378	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]379	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {380		let caller = T::CrossAccountId::from_eth(caller);381		let to = T::CrossAccountId::from_eth(to);382		let mut expected_index = <TokensMinted<T>>::get(self.id)383			.checked_add(1)384			.ok_or("item id overflow")?;385386		let total_tokens = token_ids.len();387		for id in token_ids.into_iter() {388			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;389			if id != expected_index {390				return Err("item id should be next".into());391			}392			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;393		}394		let data = (0..total_tokens)395			.map(|_| CreateItemData::<T> {396				const_data: BoundedVec::default(),397				variable_data: BoundedVec::default(),398				owner: to.clone(),399			})400			.collect();401402		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;403		Ok(true)404	}405406	#[solidity(rename_selector = "mintBulkWithTokenURI")]407	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]408	fn mint_bulk_with_token_uri(409		&mut self,410		caller: caller,411		to: address,412		tokens: Vec<(uint256, string)>,413	) -> Result<bool> {414		let caller = T::CrossAccountId::from_eth(caller);415		let to = T::CrossAccountId::from_eth(to);416		let mut expected_index = <TokensMinted<T>>::get(self.id)417			.checked_add(1)418			.ok_or("item id overflow")?;419420		let mut data = Vec::with_capacity(tokens.len());421		for (id, token_uri) in tokens {422			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;423			if id != expected_index {424				panic!("item id should be next ({}) but got {}", expected_index, id);425			}426			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;427428			data.push(CreateItemData::<T> {429				const_data: Vec::<u8>::from(token_uri)430					.try_into()431					.map_err(|_| "token uri is too long")?,432				variable_data: vec![].try_into().unwrap(),433				owner: to.clone(),434			});435		}436437		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;438		Ok(true)439	}440}441442#[solidity_interface(443	name = "UniqueNFT",444	is(445		ERC721,446		ERC721Metadata,447		ERC721Enumerable,448		ERC721UniqueExtensions,449		ERC721Mintable,450		ERC721Burnable,451	)452)]453impl<T: Config> NonfungibleHandle<T> {}454455// Not a tests, but code generators456generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);457generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);458459impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {460	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");461462	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult> {463		call::<T, UniqueNFTCall<T>, _>(*source, self, value, input)464	}465}