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

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/>.1617//! This module contains the implementation of pallet methods for evm.1819use evm_coder::{20	solidity_interface, solidity, ToLog,21	types::*,22	execution::{Result, Error},23};24pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId};25use pallet_evm_coder_substrate::dispatch_to_evm;26use sp_std::vec::Vec;27use up_data_structs::{28	Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions,29};30use alloc::format;3132use crate::{Pallet, CollectionHandle, Config, CollectionProperties};3334/// Events for ethereum collection helper.35#[derive(ToLog)]36pub enum CollectionHelpersEvents {37	/// The collection has been created.38	CollectionCreated {39		/// Collection owner.40		#[indexed]41		owner: address,4243		/// Collection ID.44		#[indexed]45		collection_id: address,46	},47}4849/// Does not always represent a full collection, for RFT it is either50/// collection (Implementing ERC721), or specific collection token (Implementing ERC20).51pub trait CommonEvmHandler {52	const CODE: &'static [u8];5354	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult>;55}5657/// @title A contract that allows you to work with collections.58#[solidity_interface(name = "Collection")]59impl<T: Config> CollectionHandle<T>60where61	T::AccountId: From<[u8; 32]>,62{63	/// Set collection property.64	///65	/// @param key Property key.66	/// @param value Propery value.67	fn set_collection_property(68		&mut self,69		caller: caller,70		key: string,71		value: bytes,72	) -> Result<void> {73		let caller = T::CrossAccountId::from_eth(caller);74		let key = <Vec<u8>>::from(key)75			.try_into()76			.map_err(|_| "key too large")?;77		let value = value.try_into().map_err(|_| "value too large")?;7879		<Pallet<T>>::set_collection_property(self, &caller, Property { key, value })80			.map_err(dispatch_to_evm::<T>)81	}8283	/// Delete collection property.84	///85	/// @param key Property key.86	fn delete_collection_property(&mut self, caller: caller, key: string) -> Result<()> {87		let caller = T::CrossAccountId::from_eth(caller);88		let key = <Vec<u8>>::from(key)89			.try_into()90			.map_err(|_| "key too large")?;9192		<Pallet<T>>::delete_collection_property(self, &caller, key).map_err(dispatch_to_evm::<T>)93	}9495	/// Get collection property.96	///97	/// @dev Throws error if key not found.98	///99	/// @param key Property key.100	/// @return bytes The property corresponding to the key.101	fn collection_property(&self, key: string) -> Result<bytes> {102		let key = <Vec<u8>>::from(key)103			.try_into()104			.map_err(|_| "key too large")?;105106		let props = <CollectionProperties<T>>::get(self.id);107		let prop = props.get(&key).ok_or("key not found")?;108109		Ok(prop.to_vec())110	}111112	/// Set the sponsor of the collection.113	///114	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.115	///116	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.117	fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {118		check_is_owner_or_admin(caller, self)?;119120		let sponsor = T::CrossAccountId::from_eth(sponsor);121		self.set_sponsor(sponsor.as_sub().clone())122			.map_err(dispatch_to_evm::<T>)?;123		save(self)124	}125126	/// Collection sponsorship confirmation.127	///128	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.129	fn confirm_collection_sponsorship(&mut self, caller: caller) -> Result<void> {130		let caller = T::CrossAccountId::from_eth(caller);131		if !self132			.confirm_sponsorship(caller.as_sub())133			.map_err(dispatch_to_evm::<T>)?134		{135			return Err("caller is not set as sponsor".into());136		}137		save(self)138	}139140	/// Set limits for the collection.141	/// @dev Throws error if limit not found.142	/// @param limit Name of the limit. Valid names:143	/// 	"accountTokenOwnershipLimit",144	/// 	"sponsoredDataSize",145	/// 	"sponsoredDataRateLimit",146	/// 	"tokenLimit",147	/// 	"sponsorTransferTimeout",148	/// 	"sponsorApproveTimeout"149	/// @param value Value of the limit.150	#[solidity(rename_selector = "setCollectionLimit")]151	fn set_int_limit(&mut self, caller: caller, limit: string, value: uint32) -> Result<void> {152		check_is_owner_or_admin(caller, self)?;153		let mut limits = self.limits.clone();154155		match limit.as_str() {156			"accountTokenOwnershipLimit" => {157				limits.account_token_ownership_limit = Some(value);158			}159			"sponsoredDataSize" => {160				limits.sponsored_data_size = Some(value);161			}162			"sponsoredDataRateLimit" => {163				limits.sponsored_data_rate_limit = Some(SponsoringRateLimit::Blocks(value));164			}165			"tokenLimit" => {166				limits.token_limit = Some(value);167			}168			"sponsorTransferTimeout" => {169				limits.sponsor_transfer_timeout = Some(value);170			}171			"sponsorApproveTimeout" => {172				limits.sponsor_approve_timeout = Some(value);173			}174			_ => {175				return Err(Error::Revert(format!(176					"unknown integer limit \"{}\"",177					limit178				)))179			}180		}181		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)182			.map_err(dispatch_to_evm::<T>)?;183		save(self)184	}185186	/// Set limits for the collection.187	/// @dev Throws error if limit not found.188	/// @param limit Name of the limit. Valid names:189	/// 	"ownerCanTransfer",190	/// 	"ownerCanDestroy",191	/// 	"transfersEnabled"192	/// @param value Value of the limit.193	#[solidity(rename_selector = "setCollectionLimit")]194	fn set_bool_limit(&mut self, caller: caller, limit: string, value: bool) -> Result<void> {195		check_is_owner_or_admin(caller, self)?;196		let mut limits = self.limits.clone();197198		match limit.as_str() {199			"ownerCanTransfer" => {200				limits.owner_can_transfer = Some(value);201			}202			"ownerCanDestroy" => {203				limits.owner_can_destroy = Some(value);204			}205			"transfersEnabled" => {206				limits.transfers_enabled = Some(value);207			}208			_ => {209				return Err(Error::Revert(format!(210					"unknown boolean limit \"{}\"",211					limit212				)))213			}214		}215		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)216			.map_err(dispatch_to_evm::<T>)?;217		save(self)218	}219220	/// Get contract address.221	fn contract_address(&self, _caller: caller) -> Result<address> {222		Ok(crate::eth::collection_id_to_address(self.id))223	}224225	/// Add collection admin by substrate address.226	/// @param new_admin Substrate administrator address.227	fn add_collection_admin_substrate(&self, caller: caller, new_admin: uint256) -> Result<void> {228		let caller = T::CrossAccountId::from_eth(caller);229		let mut new_admin_arr: [u8; 32] = Default::default();230		new_admin.to_big_endian(&mut new_admin_arr);231		let account_id = T::AccountId::from(new_admin_arr);232		let new_admin = T::CrossAccountId::from_sub(account_id);233		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;234		Ok(())235	}236237	/// Remove collection admin by substrate address.238	/// @param admin Substrate administrator address.239	fn remove_collection_admin_substrate(&self, caller: caller, admin: uint256) -> Result<void> {240		let caller = T::CrossAccountId::from_eth(caller);241		let mut admin_arr: [u8; 32] = Default::default();242		admin.to_big_endian(&mut admin_arr);243		let account_id = T::AccountId::from(admin_arr);244		let admin = T::CrossAccountId::from_sub(account_id);245		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;246		Ok(())247	}248249	/// Add collection admin.250	/// @param new_admin Address of the added administrator.251	fn add_collection_admin(&self, caller: caller, new_admin: address) -> Result<void> {252		let caller = T::CrossAccountId::from_eth(caller);253		let new_admin = T::CrossAccountId::from_eth(new_admin);254		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;255		Ok(())256	}257258	/// Remove collection admin.259	///260	/// @param new_admin Address of the removed administrator.261	fn remove_collection_admin(&self, caller: caller, admin: address) -> Result<void> {262		let caller = T::CrossAccountId::from_eth(caller);263		let admin = T::CrossAccountId::from_eth(admin);264		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;265		Ok(())266	}267268	/// Toggle accessibility of collection nesting.269	///270	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'271	#[solidity(rename_selector = "setCollectionNesting")]272	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {273		check_is_owner_or_admin(caller, self)?;274275		let mut permissions = self.collection.permissions.clone();276		let mut nesting = permissions.nesting().clone();277		nesting.token_owner = enable;278		nesting.restricted = None;279		permissions.nesting = Some(nesting);280281		self.collection.permissions = <Pallet<T>>::clamp_permissions(282			self.collection.mode.clone(),283			&self.collection.permissions,284			permissions,285		)286		.map_err(dispatch_to_evm::<T>)?;287288		save(self)289	}290291	/// Toggle accessibility of collection nesting.292	///293	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'294	/// @param collections Addresses of collections that will be available for nesting.295	#[solidity(rename_selector = "setCollectionNesting")]296	fn set_nesting(297		&mut self,298		caller: caller,299		enable: bool,300		collections: Vec<address>,301	) -> Result<void> {302		if collections.is_empty() {303			return Err("no addresses provided".into());304		}305		check_is_owner_or_admin(caller, self)?;306307		let mut permissions = self.collection.permissions.clone();308		match enable {309			false => {310				let mut nesting = permissions.nesting().clone();311				nesting.token_owner = false;312				nesting.restricted = None;313				permissions.nesting = Some(nesting);314			}315			true => {316				let mut bv = OwnerRestrictedSet::new();317				for i in collections {318					bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or(Error::Revert(319						"Can't convert address into collection id".into(),320					))?)321					.map_err(|_| "too many collections")?;322				}323				let mut nesting = permissions.nesting().clone();324				nesting.token_owner = true;325				nesting.restricted = Some(bv);326				permissions.nesting = Some(nesting);327			}328		};329330		self.collection.permissions = <Pallet<T>>::clamp_permissions(331			self.collection.mode.clone(),332			&self.collection.permissions,333			permissions,334		)335		.map_err(dispatch_to_evm::<T>)?;336337		save(self)338	}339340	/// Set the collection access method.341	/// @param mode Access mode342	/// 	0 for Normal343	/// 	1 for AllowList344	fn set_collection_access(&mut self, caller: caller, mode: uint8) -> Result<void> {345		check_is_owner_or_admin(caller, self)?;346		let permissions = CollectionPermissions {347			access: Some(match mode {348				0 => AccessMode::Normal,349				1 => AccessMode::AllowList,350				_ => return Err("not supported access mode".into()),351			}),352			..Default::default()353		};354		self.collection.permissions = <Pallet<T>>::clamp_permissions(355			self.collection.mode.clone(),356			&self.collection.permissions,357			permissions,358		)359		.map_err(dispatch_to_evm::<T>)?;360361		save(self)362	}363364	/// Add the user to the allowed list.365	///366	/// @param user Address of a trusted user.367	fn add_to_collection_allow_list(&self, caller: caller, user: address) -> Result<void> {368		let caller = T::CrossAccountId::from_eth(caller);369		let user = T::CrossAccountId::from_eth(user);370		<Pallet<T>>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;371		Ok(())372	}373374	/// Remove the user from the allowed list.375	///376	/// @param user Address of a removed user.377	fn remove_from_collection_allow_list(&self, caller: caller, user: address) -> Result<void> {378		let caller = T::CrossAccountId::from_eth(caller);379		let user = T::CrossAccountId::from_eth(user);380		<Pallet<T>>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;381		Ok(())382	}383384	/// Switch permission for minting.385	///386	/// @param mode Enable if "true".387	fn set_collection_mint_mode(&mut self, caller: caller, mode: bool) -> Result<void> {388		check_is_owner_or_admin(caller, self)?;389		let permissions = CollectionPermissions {390			mint_mode: Some(mode),391			..Default::default()392		};393		self.collection.permissions = <Pallet<T>>::clamp_permissions(394			self.collection.mode.clone(),395			&self.collection.permissions,396			permissions,397		)398		.map_err(dispatch_to_evm::<T>)?;399400		save(self)401	}402}403404fn check_is_owner_or_admin<T: Config>(405	caller: caller,406	collection: &CollectionHandle<T>,407) -> Result<T::CrossAccountId> {408	let caller = T::CrossAccountId::from_eth(caller);409	collection410		.check_is_owner_or_admin(&caller)411		.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;412	Ok(caller)413}414415fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {416	// TODO possibly delete for the lack of transaction417	collection418		.check_is_internal()419		.map_err(dispatch_to_evm::<T>)?;420	<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());421	Ok(())422}423424/// Get the "tokenURI" key as [PropertyKey](up_data_structs::PropertyKey).425pub fn token_uri_key() -> up_data_structs::PropertyKey {426	b"tokenURI"427		.to_vec()428		.try_into()429		.expect("length < limit; qed")430}