git.delta.rocks / unique-network / refs/commits / 294c410fd86d

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	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,29	SponsoringRateLimit, SponsorshipState,30};31use alloc::format;3233use crate::{34	Pallet, CollectionHandle, Config, CollectionProperties,35	eth::{36		convert_cross_account_to_uint256, convert_uint256_to_cross_account,37		convert_cross_account_to_tuple,38	},39};4041/// Events for ethereum collection helper.42#[derive(ToLog)]43pub enum CollectionHelpersEvents {44	/// The collection has been created.45	CollectionCreated {46		/// Collection owner.47		#[indexed]48		owner: address,4950		/// Collection ID.51		#[indexed]52		collection_id: address,53	},54}5556/// Does not always represent a full collection, for RFT it is either57/// collection (Implementing ERC721), or specific collection token (Implementing ERC20).58pub trait CommonEvmHandler {59	const CODE: &'static [u8];6061	/// Call precompiled handle.62	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult>;63}6465/// @title A contract that allows you to work with collections.66#[solidity_interface(name = Collection)]67impl<T: Config> CollectionHandle<T>68where69	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,70{71	/// Set collection property.72	///73	/// @param key Property key.74	/// @param value Propery value.75	fn set_collection_property(76		&mut self,77		caller: caller,78		key: string,79		value: bytes,80	) -> Result<void> {81		let caller = T::CrossAccountId::from_eth(caller);82		let key = <Vec<u8>>::from(key)83			.try_into()84			.map_err(|_| "key too large")?;85		let value = value.try_into().map_err(|_| "value too large")?;8687		<Pallet<T>>::set_collection_property(self, &caller, Property { key, value })88			.map_err(dispatch_to_evm::<T>)89	}9091	/// Delete collection property.92	///93	/// @param key Property key.94	fn delete_collection_property(&mut self, caller: caller, key: string) -> Result<()> {95		let caller = T::CrossAccountId::from_eth(caller);96		let key = <Vec<u8>>::from(key)97			.try_into()98			.map_err(|_| "key too large")?;99100		<Pallet<T>>::delete_collection_property(self, &caller, key).map_err(dispatch_to_evm::<T>)101	}102103	/// Get collection property.104	///105	/// @dev Throws error if key not found.106	///107	/// @param key Property key.108	/// @return bytes The property corresponding to the key.109	fn collection_property(&self, key: string) -> Result<bytes> {110		let key = <Vec<u8>>::from(key)111			.try_into()112			.map_err(|_| "key too large")?;113114		let props = <CollectionProperties<T>>::get(self.id);115		let prop = props.get(&key).ok_or("key not found")?;116117		Ok(prop.to_vec())118	}119120	/// Set the sponsor of the collection.121	///122	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.123	///124	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.125	fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {126		check_is_owner_or_admin(caller, self)?;127128		let sponsor = T::CrossAccountId::from_eth(sponsor);129		self.set_sponsor(sponsor.as_sub().clone())130			.map_err(dispatch_to_evm::<T>)?;131		save(self)132	}133134	/// Set the substrate sponsor of the collection.135	///136	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.137	///138	/// @param sponsor Substrate address of the sponsor from whose account funds will be debited for operations with the contract.139	fn set_collection_sponsor_substrate(140		&mut self,141		caller: caller,142		sponsor: uint256,143	) -> Result<void> {144		check_is_owner_or_admin(caller, self)?;145146		let sponsor = convert_uint256_to_cross_account::<T>(sponsor);147		self.set_sponsor(sponsor.as_sub().clone())148			.map_err(dispatch_to_evm::<T>)?;149		save(self)150	}151152	/// Whether there is a pending sponsor.153	fn has_collection_pending_sponsor(&self) -> Result<bool> {154		Ok(matches!(155			self.collection.sponsorship,156			SponsorshipState::Unconfirmed(_)157		))158	}159160	/// Collection sponsorship confirmation.161	///162	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.163	fn confirm_collection_sponsorship(&mut self, caller: caller) -> Result<void> {164		let caller = T::CrossAccountId::from_eth(caller);165		if !self166			.confirm_sponsorship(caller.as_sub())167			.map_err(dispatch_to_evm::<T>)?168		{169			return Err("caller is not set as sponsor".into());170		}171		save(self)172	}173174	/// Remove collection sponsor.175	fn remove_collection_sponsor(&mut self, caller: caller) -> Result<void> {176		check_is_owner_or_admin(caller, self)?;177		self.remove_sponsor().map_err(dispatch_to_evm::<T>)?;178		save(self)179	}180181	/// Get current sponsor.182	///183	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.184	fn get_collection_sponsor(&self) -> Result<(address, uint256)> {185		let sponsor = match self.collection.sponsorship.sponsor() {186			Some(sponsor) => sponsor,187			None => return Ok(Default::default()),188		};189		let sponsor = T::CrossAccountId::from_sub(sponsor.clone());190		let result: (address, uint256) = if sponsor.is_canonical_substrate() {191			let sponsor = convert_cross_account_to_uint256::<T>(&sponsor);192			(Default::default(), sponsor)193		} else {194			let sponsor = *sponsor.as_eth();195			(sponsor, Default::default())196		};197		Ok(result)198	}199200	/// Set limits for the collection.201	/// @dev Throws error if limit not found.202	/// @param limit Name of the limit. Valid names:203	/// 	"accountTokenOwnershipLimit",204	/// 	"sponsoredDataSize",205	/// 	"sponsoredDataRateLimit",206	/// 	"tokenLimit",207	/// 	"sponsorTransferTimeout",208	/// 	"sponsorApproveTimeout"209	/// @param value Value of the limit.210	#[solidity(rename_selector = "setCollectionLimit")]211	fn set_int_limit(&mut self, caller: caller, limit: string, value: uint32) -> Result<void> {212		check_is_owner_or_admin(caller, self)?;213		let mut limits = self.limits.clone();214215		match limit.as_str() {216			"accountTokenOwnershipLimit" => {217				limits.account_token_ownership_limit = Some(value);218			}219			"sponsoredDataSize" => {220				limits.sponsored_data_size = Some(value);221			}222			"sponsoredDataRateLimit" => {223				limits.sponsored_data_rate_limit = Some(SponsoringRateLimit::Blocks(value));224			}225			"tokenLimit" => {226				limits.token_limit = Some(value);227			}228			"sponsorTransferTimeout" => {229				limits.sponsor_transfer_timeout = Some(value);230			}231			"sponsorApproveTimeout" => {232				limits.sponsor_approve_timeout = Some(value);233			}234			_ => {235				return Err(Error::Revert(format!(236					"unknown integer limit \"{}\"",237					limit238				)))239			}240		}241		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)242			.map_err(dispatch_to_evm::<T>)?;243		save(self)244	}245246	/// Set limits for the collection.247	/// @dev Throws error if limit not found.248	/// @param limit Name of the limit. Valid names:249	/// 	"ownerCanTransfer",250	/// 	"ownerCanDestroy",251	/// 	"transfersEnabled"252	/// @param value Value of the limit.253	#[solidity(rename_selector = "setCollectionLimit")]254	fn set_bool_limit(&mut self, caller: caller, limit: string, value: bool) -> Result<void> {255		check_is_owner_or_admin(caller, self)?;256		let mut limits = self.limits.clone();257258		match limit.as_str() {259			"ownerCanTransfer" => {260				limits.owner_can_transfer = Some(value);261			}262			"ownerCanDestroy" => {263				limits.owner_can_destroy = Some(value);264			}265			"transfersEnabled" => {266				limits.transfers_enabled = Some(value);267			}268			_ => {269				return Err(Error::Revert(format!(270					"unknown boolean limit \"{}\"",271					limit272				)))273			}274		}275		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)276			.map_err(dispatch_to_evm::<T>)?;277		save(self)278	}279280	/// Get contract address.281	fn contract_address(&self) -> Result<address> {282		Ok(crate::eth::collection_id_to_address(self.id))283	}284285	/// Add collection admin by substrate address.286	/// @param newAdmin Substrate administrator address.287	fn add_collection_admin_substrate(288		&mut self,289		caller: caller,290		new_admin: uint256,291	) -> Result<void> {292		let caller = T::CrossAccountId::from_eth(caller);293		let new_admin = convert_uint256_to_cross_account::<T>(new_admin);294		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;295		Ok(())296	}297298	/// Remove collection admin by substrate address.299	/// @param admin Substrate administrator address.300	fn remove_collection_admin_substrate(301		&mut self,302		caller: caller,303		admin: uint256,304	) -> Result<void> {305		let caller = T::CrossAccountId::from_eth(caller);306		let admin = convert_uint256_to_cross_account::<T>(admin);307		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;308		Ok(())309	}310311	/// Add collection admin.312	/// @param newAdmin Address of the added administrator.313	fn add_collection_admin(&mut self, caller: caller, new_admin: address) -> Result<void> {314		let caller = T::CrossAccountId::from_eth(caller);315		let new_admin = T::CrossAccountId::from_eth(new_admin);316		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;317		Ok(())318	}319320	/// Remove collection admin.321	///322	/// @param admin Address of the removed administrator.323	fn remove_collection_admin(&mut self, caller: caller, admin: address) -> Result<void> {324		let caller = T::CrossAccountId::from_eth(caller);325		let admin = T::CrossAccountId::from_eth(admin);326		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;327		Ok(())328	}329330	/// Toggle accessibility of collection nesting.331	///332	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'333	#[solidity(rename_selector = "setCollectionNesting")]334	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {335		check_is_owner_or_admin(caller, self)?;336337		let mut permissions = self.collection.permissions.clone();338		let mut nesting = permissions.nesting().clone();339		nesting.token_owner = enable;340		nesting.restricted = None;341		permissions.nesting = Some(nesting);342343		self.collection.permissions = <Pallet<T>>::clamp_permissions(344			self.collection.mode.clone(),345			&self.collection.permissions,346			permissions,347		)348		.map_err(dispatch_to_evm::<T>)?;349350		save(self)351	}352353	/// Toggle accessibility of collection nesting.354	///355	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'356	/// @param collections Addresses of collections that will be available for nesting.357	#[solidity(rename_selector = "setCollectionNesting")]358	fn set_nesting(359		&mut self,360		caller: caller,361		enable: bool,362		collections: Vec<address>,363	) -> Result<void> {364		if collections.is_empty() {365			return Err("no addresses provided".into());366		}367		check_is_owner_or_admin(caller, self)?;368369		let mut permissions = self.collection.permissions.clone();370		match enable {371			false => {372				let mut nesting = permissions.nesting().clone();373				nesting.token_owner = false;374				nesting.restricted = None;375				permissions.nesting = Some(nesting);376			}377			true => {378				let mut bv = OwnerRestrictedSet::new();379				for i in collections {380					bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or(Error::Revert(381						"Can't convert address into collection id".into(),382					))?)383					.map_err(|_| "too many collections")?;384				}385				let mut nesting = permissions.nesting().clone();386				nesting.token_owner = true;387				nesting.restricted = Some(bv);388				permissions.nesting = Some(nesting);389			}390		};391392		self.collection.permissions = <Pallet<T>>::clamp_permissions(393			self.collection.mode.clone(),394			&self.collection.permissions,395			permissions,396		)397		.map_err(dispatch_to_evm::<T>)?;398399		save(self)400	}401402	/// Set the collection access method.403	/// @param mode Access mode404	/// 	0 for Normal405	/// 	1 for AllowList406	fn set_collection_access(&mut self, caller: caller, mode: uint8) -> Result<void> {407		check_is_owner_or_admin(caller, self)?;408		let permissions = CollectionPermissions {409			access: Some(match mode {410				0 => AccessMode::Normal,411				1 => AccessMode::AllowList,412				_ => return Err("not supported access mode".into()),413			}),414			..Default::default()415		};416		self.collection.permissions = <Pallet<T>>::clamp_permissions(417			self.collection.mode.clone(),418			&self.collection.permissions,419			permissions,420		)421		.map_err(dispatch_to_evm::<T>)?;422423		save(self)424	}425426	/// Checks that user allowed to operate with collection.427	///428	/// @param user User address to check.429	fn allowed(&self, user: address) -> Result<bool> {430		Ok(Pallet::<T>::allowed(431			self.id,432			T::CrossAccountId::from_eth(user),433		))434	}435436	/// Add the user to the allowed list.437	///438	/// @param user Address of a trusted user.439	fn add_to_collection_allow_list(&mut self, caller: caller, user: address) -> Result<void> {440		let caller = T::CrossAccountId::from_eth(caller);441		let user = T::CrossAccountId::from_eth(user);442		<Pallet<T>>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;443		Ok(())444	}445446	/// Add substrate user to allowed list.447	///448	/// @param user User substrate address.449	fn add_to_collection_allow_list_substrate(450		&mut self,451		caller: caller,452		user: uint256,453	) -> Result<void> {454		let caller = T::CrossAccountId::from_eth(caller);455		let user = convert_uint256_to_cross_account::<T>(user);456		Pallet::<T>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;457		Ok(())458	}459460	/// Remove the user from the allowed list.461	///462	/// @param user Address of a removed user.463	fn remove_from_collection_allow_list(&mut self, caller: caller, user: address) -> Result<void> {464		let caller = T::CrossAccountId::from_eth(caller);465		let user = T::CrossAccountId::from_eth(user);466		<Pallet<T>>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;467		Ok(())468	}469470	/// Remove substrate user from allowed list.471	///472	/// @param user User substrate address.473	fn remove_from_collection_allow_list_substrate(474		&mut self,475		caller: caller,476		user: uint256,477	) -> Result<void> {478		let caller = T::CrossAccountId::from_eth(caller);479		let user = convert_uint256_to_cross_account::<T>(user);480		Pallet::<T>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;481		Ok(())482	}483484	/// Switch permission for minting.485	///486	/// @param mode Enable if "true".487	fn set_collection_mint_mode(&mut self, caller: caller, mode: bool) -> Result<void> {488		check_is_owner_or_admin(caller, self)?;489		let permissions = CollectionPermissions {490			mint_mode: Some(mode),491			..Default::default()492		};493		self.collection.permissions = <Pallet<T>>::clamp_permissions(494			self.collection.mode.clone(),495			&self.collection.permissions,496			permissions,497		)498		.map_err(dispatch_to_evm::<T>)?;499500		save(self)501	}502503	/// Check that account is the owner or admin of the collection504	///505	/// @param user account to verify506	/// @return "true" if account is the owner or admin507	#[solidity(rename_selector = "isOwnerOrAdmin")]508	fn is_owner_or_admin_eth(&self, user: address) -> Result<bool> {509		let user = T::CrossAccountId::from_eth(user);510		Ok(self.is_owner_or_admin(&user))511	}512513	/// Check that substrate account is the owner or admin of the collection514	///515	/// @param user account to verify516	/// @return "true" if account is the owner or admin517	fn is_owner_or_admin_substrate(&self, user: uint256) -> Result<bool> {518		let user = convert_uint256_to_cross_account::<T>(user);519		Ok(self.is_owner_or_admin(&user))520	}521522	/// Returns collection type523	///524	/// @return `Fungible` or `NFT` or `ReFungible`525	fn unique_collection_type(&self) -> Result<string> {526		let mode = match self.collection.mode {527			CollectionMode::Fungible(_) => "Fungible",528			CollectionMode::NFT => "NFT",529			CollectionMode::ReFungible => "ReFungible",530		};531		Ok(mode.into())532	}533534	/// Get collection owner.535	///536	/// @return Tuble with sponsor address and his substrate mirror.537	/// If address is canonical then substrate mirror is zero and vice versa.538	fn collection_owner(&self) -> Result<(address, uint256)> {539		Ok(convert_cross_account_to_tuple::<T>(540			&T::CrossAccountId::from_sub(self.owner.clone()),541		))542	}543544	/// Changes collection owner to another account545	///546	/// @dev Owner can be changed only by current owner547	/// @param newOwner new owner account548	fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<void> {549		let caller = T::CrossAccountId::from_eth(caller);550		let new_owner = T::CrossAccountId::from_eth(new_owner);551		self.set_owner_internal(caller, new_owner)552			.map_err(dispatch_to_evm::<T>)553	}554555	/// Changes collection owner to another substrate account556	///557	/// @dev Owner can be changed only by current owner558	/// @param newOwner new owner substrate account559	fn set_owner_substrate(&mut self, caller: caller, new_owner: uint256) -> Result<void> {560		let caller = T::CrossAccountId::from_eth(caller);561		let new_owner = convert_uint256_to_cross_account::<T>(new_owner);562		self.set_owner_internal(caller, new_owner)563			.map_err(dispatch_to_evm::<T>)564	}565566	// TODO: need implement AbiWriter for &Vec<T>567	// fn collection_admins(&self) -> Result<Vec<(address, uint256)>> {568	// 	let result = pallet_common::IsAdmin::<T>::iter_prefix((self.id,))569	// 		.map(|(admin, _)| pallet_common::eth::convert_cross_account_to_tuple::<T>(&admin))570	// 		.collect();571	// 	Ok(result)572	// }573}574575fn check_is_owner_or_admin<T: Config>(576	caller: caller,577	collection: &CollectionHandle<T>,578) -> Result<T::CrossAccountId> {579	let caller = T::CrossAccountId::from_eth(caller);580	collection581		.check_is_owner_or_admin(&caller)582		.map_err(dispatch_to_evm::<T>)?;583	Ok(caller)584}585586fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {587	// TODO possibly delete for the lack of transaction588	collection.consume_store_writes(1)?;589	collection590		.check_is_internal()591		.map_err(dispatch_to_evm::<T>)?;592	collection.save().map_err(dispatch_to_evm::<T>)?;593	Ok(())594}595596/// Contains static property keys and values.597pub mod static_property {598	use evm_coder::{599		execution::{Result, Error},600	};601	use alloc::format;602603	const EXPECT_CONVERT_ERROR: &str = "length < limit";604605	/// Keys.606	pub mod key {607		use super::*;608609		/// Key "schemaName".610		pub fn schema_name() -> up_data_structs::PropertyKey {611			property_key_from_bytes(b"schemaName").expect(EXPECT_CONVERT_ERROR)612		}613614		/// Key "baseURI".615		pub fn base_uri() -> up_data_structs::PropertyKey {616			property_key_from_bytes(b"baseURI").expect(EXPECT_CONVERT_ERROR)617		}618619		/// Key "url".620		pub fn url() -> up_data_structs::PropertyKey {621			property_key_from_bytes(b"url").expect(EXPECT_CONVERT_ERROR)622		}623624		/// Key "suffix".625		pub fn suffix() -> up_data_structs::PropertyKey {626			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)627		}628629		/// Key "parentNft".630		pub fn parent_nft() -> up_data_structs::PropertyKey {631			property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR)632		}633	}634635	/// Values.636	pub mod value {637		use super::*;638639		/// Value "ERC721Metadata".640		pub const ERC721_METADATA: &[u8] = b"ERC721Metadata";641642		/// Value for [`ERC721_METADATA`].643		pub fn erc721() -> up_data_structs::PropertyValue {644			property_value_from_bytes(ERC721_METADATA).expect(EXPECT_CONVERT_ERROR)645		}646	}647648	/// Convert `byte` to [`PropertyKey`].649	pub fn property_key_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyKey> {650		bytes.to_vec().try_into().map_err(|_| {651			Error::Revert(format!(652				"Property key is too long. Max length is {}.",653				up_data_structs::PropertyKey::bound()654			))655		})656	}657658	/// Convert `bytes` to [`PropertyValue`].659	pub fn property_value_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyValue> {660		bytes.to_vec().try_into().map_err(|_| {661			Error::Revert(format!(662				"Property key is too long. Max length is {}.",663				up_data_structs::PropertyKey::bound()664			))665		})666	}667}