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

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//! Implementation of CollectionHelpers contract.18//!19use alloc::{collections::BTreeSet, format};20use core::marker::PhantomData;2122use ethereum as _;23use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*};24use frame_support::{traits::Get, BoundedVec};25use pallet_common::{26	dispatch::CollectionDispatch,27	erc::{static_property::key, CollectionHelpersEvents},28	eth::{self, collection_id_to_address, map_eth_to_id},29	CollectionById, CollectionHandle, Pallet as PalletCommon,30};31use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult};32use pallet_evm_coder_substrate::{33	dispatch_to_evm,34	execution::{Error, PreDispatch, Result},35	frontier_contract, SubstrateRecorder, WithRecorder,36};37use sp_std::vec::Vec;38use up_data_structs::{39	CollectionDescription, CollectionMode, CollectionName, CollectionPermissions,40	CollectionTokenPrefix, CreateCollectionData, NestingPermissions,41};4243use crate::{weights::WeightInfo, Config, Pallet, SelfWeightOf};4445frontier_contract! {46	macro_rules! EvmCollectionHelpers_result {...}47	impl<T: Config> Contract for EvmCollectionHelpers<T> {...}48}49/// See [`CollectionHelpersCall`]50pub struct EvmCollectionHelpers<T: Config>(SubstrateRecorder<T>);51impl<T: Config> WithRecorder<T> for EvmCollectionHelpers<T> {52	fn recorder(&self) -> &SubstrateRecorder<T> {53		&self.054	}5556	fn into_recorder(self) -> SubstrateRecorder<T> {57		self.058	}59}6061fn convert_data<T: Config>(62	caller: Caller,63	name: String,64	description: String,65	token_prefix: String,66) -> Result<(67	T::CrossAccountId,68	CollectionName,69	CollectionDescription,70	CollectionTokenPrefix,71)> {72	let caller = T::CrossAccountId::from_eth(caller);73	let name = name74		.encode_utf16()75		.collect::<Vec<u16>>()76		.try_into()77		.map_err(|_| error_field_too_long(stringify!(name), CollectionName::bound()))?;78	let description = description79		.encode_utf16()80		.collect::<Vec<u16>>()81		.try_into()82		.map_err(|_| {83			error_field_too_long(stringify!(description), CollectionDescription::bound())84		})?;85	let token_prefix = token_prefix.into_bytes().try_into().map_err(|_| {86		error_field_too_long(stringify!(token_prefix), CollectionTokenPrefix::bound())87	})?;88	Ok((caller, name, description, token_prefix))89}9091#[inline(always)]92fn create_collection_internal<T: Config>(93	caller: Caller,94	value: Value,95	name: String,96	collection_mode: CollectionMode,97	description: String,98	token_prefix: String,99) -> Result<Address> {100	let (caller, name, description, token_prefix) =101		convert_data::<T>(caller, name, description, token_prefix)?;102	let data = CreateCollectionData {103		name,104		mode: collection_mode,105		description,106		token_prefix,107		..Default::default()108	};109	check_sent_amount_equals_collection_creation_price::<T>(value)?;110	let collection_helpers_address =111		T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());112113	let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)114		.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;115	let address = pallet_common::eth::collection_id_to_address(collection_id);116	Ok(address)117}118119fn check_sent_amount_equals_collection_creation_price<T: Config>(value: Value) -> Result<()> {120	let value = value.as_u128();121	let creation_price: u128 = T::CollectionCreationPrice::get()122		.try_into()123		.map_err(|_| ()) // workaround for `expect` requiring `Debug` trait124		.expect("Collection creation price should be convertible to u128");125	if value != creation_price {126		return Err(format!(127			"Sent amount not equals to collection creation price ({creation_price})",128		)129		.into());130	}131	Ok(())132}133134/// @title Contract, which allows users to operate with collections135#[solidity_interface(name = CollectionHelpers, events(CollectionHelpersEvents), enum(derive(PreDispatch)), enum_attr(weight))]136impl<T> EvmCollectionHelpers<T>137where138	T: Config + pallet_common::Config + pallet_nonfungible::Config + pallet_refungible::Config,139	T::AccountId: From<[u8; 32]>,140{141	/// Create a collection142	/// @return address Address of the newly created collection143	#[weight(<SelfWeightOf<T>>::create_collection())]144	#[solidity(rename_selector = "createCollection")]145	fn create_collection(146		&mut self,147		caller: Caller,148		value: Value,149		data: eth::CreateCollectionData,150	) -> Result<Address> {151		let (caller, name, description, token_prefix) =152			convert_data::<T>(caller, data.name, data.description, data.token_prefix)?;153		if data.mode != eth::CollectionMode::Fungible && data.decimals != 0 {154			return Err("decimals are only supported for NFT and RFT collections".into());155		}156		let mode = match data.mode {157			eth::CollectionMode::Fungible => CollectionMode::Fungible(data.decimals),158			eth::CollectionMode::Nonfungible => CollectionMode::NFT,159			eth::CollectionMode::Refungible => CollectionMode::ReFungible,160		};161162		let properties: BoundedVec<_, _> = data163			.properties164			.into_iter()165			.map(eth::Property::try_into)166			.collect::<Result<Vec<_>>>()?167			.try_into()168			.map_err(|_| "too many properties")?;169170		let token_property_permissions =171			eth::TokenPropertyPermission::into_property_key_permissions(172				data.token_property_permissions,173			)?174			.try_into()175			.map_err(|_| "too many property permissions")?;176177		let limits = if !data.limits.is_empty() {178			Some(179				data.limits180					.into_iter()181					.collect::<Result<up_data_structs::CollectionLimits>>()?,182			)183		} else {184			None185		};186187		let pending_sponsor = data.pending_sponsor.into_option_sub_cross_account::<T>()?;188189		let restricted = if !data.nesting_settings.restricted.is_empty() {190			Some(191				data.nesting_settings192					.restricted193					.iter()194					.map(map_eth_to_id)195					.collect::<Option<BTreeSet<_>>>()196					.ok_or("can't convert address into collection id")?197					.try_into()198					.map_err(|_| "too many collections")?,199			)200		} else {201			None202		};203204		let admin_list = data205			.admin_list206			.into_iter()207			.map(|admin| admin.into_sub_cross_account::<T>())208			.collect::<Result<Vec<_>>>()?;209210		let flags = data.flags;211		if !flags.is_allowed_for_user() {212			return Err("internal flags were used".into());213		}214215		let data = CreateCollectionData {216			name,217			mode,218			description,219			token_prefix,220			properties,221			token_property_permissions,222			limits,223			pending_sponsor,224			access: None,225			permissions: Some(CollectionPermissions {226				access: None,227				mint_mode: None,228				nesting: Some(NestingPermissions {229					token_owner: data.nesting_settings.token_owner,230					collection_admin: data.nesting_settings.collection_admin,231					restricted,232					#[cfg(feature = "runtime-benchmarks")]233					permissive: true,234				}),235			}),236			admin_list,237			flags,238		};239		check_sent_amount_equals_collection_creation_price::<T>(value)?;240		let collection_helpers_address =241			T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());242243		let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)244			.map_err(dispatch_to_evm::<T>)?;245246		let address = pallet_common::eth::collection_id_to_address(collection_id);247		Ok(address)248	}249250	/// Create an NFT collection251	/// @param name Name of the collection252	/// @param description Informative description of the collection253	/// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications254	/// @return address Address of the newly created collection255	#[weight(<SelfWeightOf<T>>::create_collection())]256	#[solidity(rename_selector = "createNFTCollection")]257	fn create_nft_collection(258		&mut self,259		caller: Caller,260		value: Value,261		name: String,262		description: String,263		token_prefix: String,264	) -> Result<Address> {265		let (caller, name, description, token_prefix) =266			convert_data::<T>(caller, name, description, token_prefix)?;267		let data = CreateCollectionData {268			name,269			mode: CollectionMode::NFT,270			description,271			token_prefix,272			..Default::default()273		};274		check_sent_amount_equals_collection_creation_price::<T>(value)?;275		let collection_helpers_address =276			T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());277		let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)278			.map_err(dispatch_to_evm::<T>)?;279280		let address = pallet_common::eth::collection_id_to_address(collection_id);281		Ok(address)282	}283	/// Create an NFT collection284	/// @param name Name of the collection285	/// @param description Informative description of the collection286	/// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications287	/// @return address Address of the newly created collection288	#[deprecated(note = "mathod was renamed to `create_nft_collection`, prefer it instead")]289	#[solidity(hide)]290	#[weight(<SelfWeightOf<T>>::create_collection())]291	fn create_nonfungible_collection(292		&mut self,293		caller: Caller,294		value: Value,295		name: String,296		description: String,297		token_prefix: String,298	) -> Result<Address> {299		create_collection_internal::<T>(300			caller,301			value,302			name,303			CollectionMode::NFT,304			description,305			token_prefix,306		)307	}308309	#[weight(<SelfWeightOf<T>>::create_collection())]310	#[solidity(rename_selector = "createRFTCollection")]311	fn create_rft_collection(312		&mut self,313		caller: Caller,314		value: Value,315		name: String,316		description: String,317		token_prefix: String,318	) -> Result<Address> {319		create_collection_internal::<T>(320			caller,321			value,322			name,323			CollectionMode::ReFungible,324			description,325			token_prefix,326		)327	}328329	#[weight(<SelfWeightOf<T>>::create_collection())]330	#[solidity(rename_selector = "createFTCollection")]331	fn create_fungible_collection(332		&mut self,333		caller: Caller,334		value: Value,335		name: String,336		decimals: u8,337		description: String,338		token_prefix: String,339	) -> Result<Address> {340		create_collection_internal::<T>(341			caller,342			value,343			name,344			CollectionMode::Fungible(decimals),345			description,346			token_prefix,347		)348	}349350	#[solidity(rename_selector = "makeCollectionERC721MetadataCompatible")]351	fn make_collection_metadata_compatible(352		&mut self,353		caller: Caller,354		collection: Address,355		base_uri: String,356	) -> Result<()> {357		let caller = T::CrossAccountId::from_eth(caller);358		let collection =359			pallet_common::eth::map_eth_to_id(&collection).ok_or("not a collection address")?;360		let mut collection =361			<CollectionHandle<T>>::new(collection).ok_or("collection not found")?;362363		if !matches!(364			collection.mode,365			CollectionMode::NFT | CollectionMode::ReFungible366		) {367			return Err("target collection should be either NFT or Refungible".into());368		}369370		self.recorder().consume_sstore()?;371		collection372			.check_is_owner_or_admin(&caller)373			.map_err(dispatch_to_evm::<T>)?;374375		if collection.flags.erc721metadata {376			return Err("target collection is already Erc721Metadata compatible".into());377		}378		collection.flags.erc721metadata = true;379380		let all_permissions = <pallet_common::CollectionPropertyPermissions<T>>::get(collection.id);381		if all_permissions.get(&key::url()).is_none() {382			self.recorder().consume_sstore()?;383			<PalletCommon<T>>::set_property_permission(384				&collection,385				&caller,386				up_data_structs::PropertyKeyPermission {387					key: key::url(),388					permission: up_data_structs::PropertyPermission {389						mutable: true,390						collection_admin: true,391						token_owner: false,392					},393				},394			)395			.map_err(dispatch_to_evm::<T>)?;396		}397		if all_permissions.get(&key::suffix()).is_none() {398			self.recorder().consume_sstore()?;399			<PalletCommon<T>>::set_property_permission(400				&collection,401				&caller,402				up_data_structs::PropertyKeyPermission {403					key: key::suffix(),404					permission: up_data_structs::PropertyPermission {405						mutable: true,406						collection_admin: true,407						token_owner: false,408					},409				},410			)411			.map_err(dispatch_to_evm::<T>)?;412		}413414		let all_properties = <pallet_common::CollectionProperties<T>>::get(collection.id);415		if all_properties.get(&key::base_uri()).is_none() && !base_uri.is_empty() {416			self.recorder().consume_sstore()?;417			<PalletCommon<T>>::set_collection_properties(418				&collection,419				&caller,420				[up_data_structs::Property {421					key: key::base_uri(),422					value: base_uri423						.into_bytes()424						.try_into()425						.map_err(|_| "base uri is too large")?,426				}]427				.into_iter(),428			)429			.map_err(dispatch_to_evm::<T>)?;430		}431432		self.recorder().consume_sstore()?;433		collection.save().map_err(dispatch_to_evm::<T>)?;434435		Ok(())436	}437438	#[weight(<SelfWeightOf<T>>::destroy_collection())]439	fn destroy_collection(&mut self, caller: Caller, collection_address: Address) -> Result<()> {440		let caller = T::CrossAccountId::from_eth(caller);441442		let collection_id = pallet_common::eth::map_eth_to_id(&collection_address)443			.ok_or("Invalid collection address format")?;444		<Pallet<T>>::destroy_collection_internal(caller, collection_id)445			.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)446	}447448	/// Check if a collection exists449	/// @param collectionAddress Address of the collection in question450	/// @return bool Does the collection exist?451	fn is_collection_exist(&self, _caller: Caller, collection_address: Address) -> Result<bool> {452		if let Some(id) = pallet_common::eth::map_eth_to_id(&collection_address) {453			let collection_id = id;454			return Ok(<CollectionById<T>>::contains_key(collection_id));455		}456457		Ok(false)458	}459460	fn collection_creation_fee(&self) -> Result<Value> {461		let price: u128 = T::CollectionCreationPrice::get()462			.try_into()463			.map_err(|_| ()) // workaround for `expect` requiring `Debug` trait464			.expect("Collection creation price should be convertible to u128");465		Ok(price.into())466	}467468	/// Returns address of a collection.469	/// @param collectionId  - CollectionId  of the collection470	/// @return eth mirror address of the collection471	fn collection_address(&self, collection_id: u32) -> Result<Address> {472		Ok(collection_id_to_address(collection_id.into()))473	}474475	/// Returns collectionId of a collection.476	/// @param collectionAddress  - Eth address of the collection477	/// @return collectionId of the collection478	fn collection_id(&self, collection_address: Address) -> Result<u32> {479		map_eth_to_id(&collection_address)480			.map(|id| id.0)481			.ok_or(Error::Revert(format!(482				"failed to convert address {collection_address} into collectionId."483			)))484	}485}486487/// Implements [`OnMethodCall`], which delegates call to [`EvmCollectionHelpers`]488pub struct CollectionHelpersOnMethodCall<T: Config>(PhantomData<*const T>);489impl<T: Config + pallet_nonfungible::Config + pallet_refungible::Config> OnMethodCall<T>490	for CollectionHelpersOnMethodCall<T>491where492	T::AccountId: From<[u8; 32]>,493{494	fn is_reserved(contract: &sp_core::H160) -> bool {495		contract == &T::ContractAddress::get()496	}497498	fn is_used(contract: &sp_core::H160) -> bool {499		contract == &T::ContractAddress::get()500	}501502	fn call(handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {503		if handle.code_address() != T::ContractAddress::get() {504			return None;505		}506507		let helpers =508			EvmCollectionHelpers::<T>(SubstrateRecorder::<T>::new(handle.remaining_gas()));509		pallet_evm_coder_substrate::call(handle, helpers)510	}511512	fn get_code(contract: &sp_core::H160) -> Option<Vec<u8>> {513		(contract == &T::ContractAddress::get())514			.then(|| include_bytes!("./stubs/CollectionHelpers.raw").to_vec())515	}516}517518generate_stubgen!(collection_helper_impl, CollectionHelpersCall<()>, true);519generate_stubgen!(collection_helper_iface, CollectionHelpersCall<()>, false);520521fn error_field_too_long(feild: &str, bound: usize) -> Error {522	Error::Revert(format!("{feild} is too long. Max length is {bound}."))523}