git.delta.rocks / unique-network / refs/commits / 02783a223963

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;3334use crate::{35	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,36	SelfWeightOf, weights::WeightInfo,37};3839fn error_unsupported_schema_version() -> Error {40	alloc::format!(41		"Unsupported schema version! Support only {:?}",42		SchemaVersion::ImageURL43	)44	.as_str()45	.into()46}4748#[derive(ToLog)]49pub enum ERC721Events {50	Transfer {51		#[indexed]52		from: address,53		#[indexed]54		to: address,55		#[indexed]56		token_id: uint256,57	},58	Approval {59		#[indexed]60		owner: address,61		#[indexed]62		approved: address,63		#[indexed]64		token_id: uint256,65	},66	#[allow(dead_code)]67	ApprovalForAll {68		#[indexed]69		owner: address,70		#[indexed]71		operator: address,72		approved: bool,73	},74}7576#[derive(ToLog)]77pub enum ERC721MintableEvents {78	#[allow(dead_code)]79	MintingFinished {},80}8182#[solidity_interface(name = "ERC721Metadata")]83impl<T: Config> NonfungibleHandle<T> {84	fn name(&self) -> Result<string> {85		Ok(decode_utf16(self.name.iter().copied())86			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))87			.collect::<string>())88	}8990	fn symbol(&self) -> Result<string> {91		Ok(string::from_utf8_lossy(&self.token_prefix).into())92	}9394	/// Returns token's const_metadata95	#[solidity(rename_selector = "tokenURI")]96	fn token_uri(&self, token_id: uint256) -> Result<string> {97		if !matches!(self.schema_version, SchemaVersion::ImageURL) {98			return Err(error_unsupported_schema_version());99		}100101		self.consume_store_reads(1)?;102		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;103		Ok(string::from_utf8_lossy(104			&<TokenData<T>>::get((self.id, token_id))105				.ok_or("token not found")?106				.const_data,107		)108		.into())109	}110}111112#[solidity_interface(name = "ERC721Enumerable")]113impl<T: Config> NonfungibleHandle<T> {114	fn token_by_index(&self, index: uint256) -> Result<uint256> {115		Ok(index)116	}117118	/// Not implemented119	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {120		// TODO: Not implemetable121		Err("not implemented".into())122	}123124	fn total_supply(&self) -> Result<uint256> {125		self.consume_store_reads(1)?;126		Ok(<Pallet<T>>::total_supply(self).into())127	}128}129130#[solidity_interface(name = "ERC721", events(ERC721Events))]131impl<T: Config> NonfungibleHandle<T> {132	fn balance_of(&self, owner: address) -> Result<uint256> {133		self.consume_store_reads(1)?;134		let owner = T::CrossAccountId::from_eth(owner);135		let balance = <AccountBalance<T>>::get((self.id, owner));136		Ok(balance.into())137	}138	fn owner_of(&self, token_id: uint256) -> Result<address> {139		self.consume_store_reads(1)?;140		let token: TokenId = token_id.try_into()?;141		Ok(*<TokenData<T>>::get((self.id, token))142			.ok_or("token not found")?143			.owner144			.as_eth())145	}146	/// Not implemented147	fn safe_transfer_from_with_data(148		&mut self,149		_from: address,150		_to: address,151		_token_id: uint256,152		_data: bytes,153		_value: value,154	) -> Result<void> {155		// TODO: Not implemetable156		Err("not implemented".into())157	}158	/// Not implemented159	fn safe_transfer_from(160		&mut self,161		_from: address,162		_to: address,163		_token_id: uint256,164		_value: value,165	) -> Result<void> {166		// TODO: Not implemetable167		Err("not implemented".into())168	}169170	#[weight(<SelfWeightOf<T>>::transfer_from())]171	fn transfer_from(172		&mut self,173		caller: caller,174		from: address,175		to: address,176		token_id: uint256,177		_value: value,178	) -> Result<void> {179		let caller = T::CrossAccountId::from_eth(caller);180		let from = T::CrossAccountId::from_eth(from);181		let to = T::CrossAccountId::from_eth(to);182		let token = token_id.try_into()?;183184		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token)185			.map_err(dispatch_to_evm::<T>)?;186		Ok(())187	}188189	#[weight(<SelfWeightOf<T>>::approve())]190	fn approve(191		&mut self,192		caller: caller,193		approved: address,194		token_id: uint256,195		_value: value,196	) -> Result<void> {197		let caller = T::CrossAccountId::from_eth(caller);198		let approved = T::CrossAccountId::from_eth(approved);199		let token = token_id.try_into()?;200201		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))202			.map_err(dispatch_to_evm::<T>)?;203		Ok(())204	}205206	/// Not implemented207	fn set_approval_for_all(208		&mut self,209		_caller: caller,210		_operator: address,211		_approved: bool,212	) -> Result<void> {213		// TODO: Not implemetable214		Err("not implemented".into())215	}216217	/// Not implemented218	fn get_approved(&self, _token_id: uint256) -> Result<address> {219		// TODO: Not implemetable220		Err("not implemented".into())221	}222223	/// Not implemented224	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {225		// TODO: Not implemetable226		Err("not implemented".into())227	}228}229230#[solidity_interface(name = "ERC721Burnable")]231impl<T: Config> NonfungibleHandle<T> {232	#[weight(<SelfWeightOf<T>>::burn_item())]233	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {234		let caller = T::CrossAccountId::from_eth(caller);235		let token = token_id.try_into()?;236237		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;238		Ok(())239	}240}241242#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]243impl<T: Config> NonfungibleHandle<T> {244	fn minting_finished(&self) -> Result<bool> {245		Ok(false)246	}247248	/// `token_id` should be obtained with `next_token_id` method,249	/// unlike standard, you can't specify it manually250	#[weight(<SelfWeightOf<T>>::create_item())]251	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {252		let caller = T::CrossAccountId::from_eth(caller);253		let to = T::CrossAccountId::from_eth(to);254		let token_id: u32 = token_id.try_into()?;255		if <TokensMinted<T>>::get(self.id)256			.checked_add(1)257			.ok_or("item id overflow")?258			!= token_id259		{260			return Err("item id should be next".into());261		}262263		<Pallet<T>>::create_item(264			self,265			&caller,266			CreateItemData::<T> {267				const_data: BoundedVec::default(),268				variable_data: BoundedVec::default(),269				owner: to,270			},271		)272		.map_err(dispatch_to_evm::<T>)?;273274		Ok(true)275	}276277	/// `token_id` should be obtained with `next_token_id` method,278	/// unlike standard, you can't specify it manually279	#[solidity(rename_selector = "mintWithTokenURI")]280	#[weight(<SelfWeightOf<T>>::create_item())]281	fn mint_with_token_uri(282		&mut self,283		caller: caller,284		to: address,285		token_id: uint256,286		token_uri: string,287	) -> Result<bool> {288		if !matches!(self.schema_version, SchemaVersion::ImageURL) {289			return Err(error_unsupported_schema_version());290		}291292		let caller = T::CrossAccountId::from_eth(caller);293		let to = T::CrossAccountId::from_eth(to);294		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;295		if <TokensMinted<T>>::get(self.id)296			.checked_add(1)297			.ok_or("item id overflow")?298			!= token_id299		{300			return Err("item id should be next".into());301		}302303		<Pallet<T>>::create_item(304			self,305			&caller,306			CreateItemData::<T> {307				const_data: Vec::<u8>::from(token_uri)308					.try_into()309					.map_err(|_| "token uri is too long")?,310				variable_data: BoundedVec::default(),311				owner: to,312			},313		)314		.map_err(dispatch_to_evm::<T>)?;315		Ok(true)316	}317318	/// Not implemented319	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {320		Err("not implementable".into())321	}322}323324#[solidity_interface(name = "ERC721UniqueExtensions")]325impl<T: Config> NonfungibleHandle<T> {326	#[weight(<SelfWeightOf<T>>::transfer())]327	fn transfer(328		&mut self,329		caller: caller,330		to: address,331		token_id: uint256,332		_value: value,333	) -> Result<void> {334		let caller = T::CrossAccountId::from_eth(caller);335		let to = T::CrossAccountId::from_eth(to);336		let token = token_id.try_into()?;337338		<Pallet<T>>::transfer(self, &caller, &to, token).map_err(dispatch_to_evm::<T>)?;339		Ok(())340	}341342	#[weight(<SelfWeightOf<T>>::burn_from())]343	fn burn_from(344		&mut self,345		caller: caller,346		from: address,347		token_id: uint256,348		_value: value,349	) -> Result<void> {350		let caller = T::CrossAccountId::from_eth(caller);351		let from = T::CrossAccountId::from_eth(from);352		let token = token_id.try_into()?;353354		<Pallet<T>>::burn_from(self, &caller, &from, token).map_err(dispatch_to_evm::<T>)?;355		Ok(())356	}357358	fn next_token_id(&self) -> Result<uint256> {359		self.consume_store_reads(1)?;360		Ok(<TokensMinted<T>>::get(self.id)361			.checked_add(1)362			.ok_or("item id overflow")?363			.into())364	}365366	#[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]367	fn set_variable_metadata(368		&mut self,369		caller: caller,370		token_id: uint256,371		data: bytes,372	) -> Result<void> {373		let caller = T::CrossAccountId::from_eth(caller);374		let token = token_id.try_into()?;375376		<Pallet<T>>::set_variable_metadata(377			self,378			&caller,379			token,380			data.try_into()381				.map_err(|_| "metadata size exceeded limit")?,382		)383		.map_err(dispatch_to_evm::<T>)?;384		Ok(())385	}386387	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {388		self.consume_store_reads(1)?;389		let token: TokenId = token_id.try_into()?;390391		Ok(<TokenData<T>>::get((self.id, token))392			.ok_or("token not found")?393			.variable_data394			.into_inner())395	}396397	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]398	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {399		let caller = T::CrossAccountId::from_eth(caller);400		let to = T::CrossAccountId::from_eth(to);401		let mut expected_index = <TokensMinted<T>>::get(self.id)402			.checked_add(1)403			.ok_or("item id overflow")?;404405		let total_tokens = token_ids.len();406		for id in token_ids.into_iter() {407			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;408			if id != expected_index {409				return Err("item id should be next".into());410			}411			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;412		}413		let data = (0..total_tokens)414			.map(|_| CreateItemData::<T> {415				const_data: BoundedVec::default(),416				variable_data: BoundedVec::default(),417				owner: to.clone(),418			})419			.collect();420421		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;422		Ok(true)423	}424425	#[solidity(rename_selector = "mintBulkWithTokenURI")]426	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]427	fn mint_bulk_with_token_uri(428		&mut self,429		caller: caller,430		to: address,431		tokens: Vec<(uint256, string)>,432	) -> Result<bool> {433		if !matches!(self.schema_version, SchemaVersion::ImageURL) {434			return Err(error_unsupported_schema_version());435		}436437		let caller = T::CrossAccountId::from_eth(caller);438		let to = T::CrossAccountId::from_eth(to);439		let mut expected_index = <TokensMinted<T>>::get(self.id)440			.checked_add(1)441			.ok_or("item id overflow")?;442443		let mut data = Vec::with_capacity(tokens.len());444		for (id, token_uri) in tokens {445			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;446			if id != expected_index {447				panic!("item id should be next ({}) but got {}", expected_index, id);448			}449			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;450451			data.push(CreateItemData::<T> {452				const_data: Vec::<u8>::from(token_uri)453					.try_into()454					.map_err(|_| "token uri is too long")?,455				variable_data: vec![].try_into().unwrap(),456				owner: to.clone(),457			});458		}459460		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;461		Ok(true)462	}463}464465#[solidity_interface(466	name = "UniqueNFT",467	is(468		ERC721,469		ERC721Metadata,470		ERC721Enumerable,471		ERC721UniqueExtensions,472		ERC721Mintable,473		ERC721Burnable,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}