git.delta.rocks / unique-network / refs/commits / 6486f2a91bb1

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 core::marker::PhantomData;20use ethereum as _;21use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*};22use frame_support::{BoundedVec, traits::Get};23use pallet_common::{24	CollectionById,25	dispatch::CollectionDispatch,26	erc::{CollectionHelpersEvents, static_property::key},27	eth::{self, map_eth_to_id, collection_id_to_address},28	Pallet as PalletCommon, CollectionHandle,29};30use pallet_evm::{account::CrossAccountId, OnMethodCall, PrecompileHandle, PrecompileResult};31use pallet_evm_coder_substrate::{32	dispatch_to_evm, SubstrateRecorder, WithRecorder,33	execution::{PreDispatch, Result, Error},34	frontier_contract,35};36use up_data_structs::{37	CollectionDescription, CollectionMode, CollectionName, CollectionPermissions,38	CollectionTokenPrefix, CreateCollectionData, NestingPermissions,39};4041use crate::{weights::WeightInfo, Config, Pallet, SelfWeightOf};4243use alloc::{format, collections::BTreeSet};44use sp_std::vec::Vec;4546frontier_contract! {47	macro_rules! EvmCollectionHelpers_result {...}48	impl<T: Config> Contract for EvmCollectionHelpers<T> {...}49}50/// See [`CollectionHelpersCall`]51pub struct EvmCollectionHelpers<T: Config>(SubstrateRecorder<T>);52impl<T: Config> WithRecorder<T> for EvmCollectionHelpers<T> {53	fn recorder(&self) -> &SubstrateRecorder<T> {54		&self.055	}5657	fn into_recorder(self) -> SubstrateRecorder<T> {58		self.059	}60}6162fn convert_data<T: Config>(63	caller: Caller,64	name: String,65	description: String,66	token_prefix: String,67) -> Result<(68	T::CrossAccountId,69	CollectionName,70	CollectionDescription,71	CollectionTokenPrefix,72)> {73	let caller = T::CrossAccountId::from_eth(caller);74	let name = name75		.encode_utf16()76		.collect::<Vec<u16>>()77		.try_into()78		.map_err(|_| error_field_too_long(stringify!(name), CollectionName::bound()))?;79	let description = description80		.encode_utf16()81		.collect::<Vec<u16>>()82		.try_into()83		.map_err(|_| {84			error_field_too_long(stringify!(description), CollectionDescription::bound())85		})?;86	let token_prefix = token_prefix.into_bytes().try_into().map_err(|_| {87		error_field_too_long(stringify!(token_prefix), CollectionTokenPrefix::bound())88	})?;89	Ok((caller, name, description, token_prefix))90}9192#[inline(always)]93fn create_collection_internal<T: Config>(94	caller: Caller,95	value: Value,96	name: String,97	collection_mode: CollectionMode,98	description: String,99	token_prefix: String,100) -> Result<Address> {101	let (caller, name, description, token_prefix) =102		convert_data::<T>(caller, name, description, token_prefix)?;103	let data = CreateCollectionData {104		name,105		mode: collection_mode,106		description,107		token_prefix,108		..Default::default()109	};110	check_sent_amount_equals_collection_creation_price::<T>(value)?;111	let collection_helpers_address =112		T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());113114	let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)115		.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;116	let address = pallet_common::eth::collection_id_to_address(collection_id);117	Ok(address)118}119120fn check_sent_amount_equals_collection_creation_price<T: Config>(value: Value) -> Result<()> {121	let value = value.as_u128();122	let creation_price: u128 = T::CollectionCreationPrice::get()123		.try_into()124		.map_err(|_| ()) // workaround for `expect` requiring `Debug` trait125		.expect("Collection creation price should be convertible to u128");126	if value != creation_price {127		return Err(format!(128			"Sent amount not equals to collection creation price ({creation_price})",129		)130		.into());131	}132	Ok(())133}134135/// @title Contract, which allows users to operate with collections136#[solidity_interface(name = CollectionHelpers, events(CollectionHelpersEvents), enum(derive(PreDispatch)), enum_attr(weight))]137impl<T> EvmCollectionHelpers<T>138where139	T: Config + pallet_common::Config + pallet_nonfungible::Config + pallet_refungible::Config,140	T::AccountId: From<[u8; 32]>,141{142	/// Create a collection143	/// @return address Address of the newly created collection144	#[weight(<SelfWeightOf<T>>::create_collection())]145	#[solidity(rename_selector = "createCollection")]146	fn create_collection(147		&mut self,148		caller: Caller,149		value: Value,150		data: eth::CreateCollectionData,151	) -> Result<Address> {152		let (caller, name, description, token_prefix) =153			convert_data::<T>(caller, data.name, data.description, data.token_prefix)?;154		if data.mode != eth::CollectionMode::Fungible && data.decimals != 0 {155			return Err("decimals are only supported for NFT and RFT collections".into());156		}157		let mode = match data.mode {158			eth::CollectionMode::Fungible => CollectionMode::Fungible(data.decimals),159			eth::CollectionMode::Nonfungible => CollectionMode::NFT,160			eth::CollectionMode::Refungible => CollectionMode::ReFungible,161		};162163		let properties: BoundedVec<_, _> = data164			.properties165			.into_iter()166			.map(eth::Property::try_into)167			.collect::<Result<Vec<_>>>()?168			.try_into()169			.map_err(|_| "too many properties")?;170171		let token_property_permissions =172			eth::TokenPropertyPermission::into_property_key_permissions(173				data.token_property_permissions,174			)?175			.try_into()176			.map_err(|_| "too many property permissions")?;177178		let limits = if !data.limits.is_empty() {179			Some(180				data.limits181					.into_iter()182					.collect::<Result<up_data_structs::CollectionLimits>>()?,183			)184		} else {185			None186		};187188		let pending_sponsor = data.pending_sponsor.into_option_sub_cross_account::<T>()?;189190		let restricted = if !data.nesting_settings.restricted.is_empty() {191			Some(192				data.nesting_settings193					.restricted194					.iter()195					.map(map_eth_to_id)196					.collect::<Option<BTreeSet<_>>>()197					.ok_or("can't convert address into collection id")?198					.try_into()199					.map_err(|_| "too many collections")?,200			)201		} else {202			None203		};204205		let admin_list = data206			.admin_list207			.into_iter()208			.map(|admin| admin.into_sub_cross_account::<T>())209			.collect::<Result<Vec<_>>>()?;210211		let flags = data.flags;212		if !flags.is_allowed_for_user() {213			return Err("internal flags were used".into());214		}215216		let data = CreateCollectionData {217			name,218			mode,219			description,220			token_prefix,221			properties,222			token_property_permissions,223			limits,224			pending_sponsor,225			access: None,226			permissions: Some(CollectionPermissions {227				access: None,228				mint_mode: None,229				nesting: Some(NestingPermissions {230					token_owner: data.nesting_settings.token_owner,231					collection_admin: data.nesting_settings.collection_admin,232					restricted,233					#[cfg(feature = "runtime-benchmarks")]234					permissive: true,235				}),236			}),237			admin_list,238			flags,239		};240		check_sent_amount_equals_collection_creation_price::<T>(value)?;241		let collection_helpers_address =242			T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());243244		let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)245			.map_err(dispatch_to_evm::<T>)?;246247		let address = pallet_common::eth::collection_id_to_address(collection_id);248		Ok(address)249	}250251	/// Create an NFT collection252	/// @param name Name of the collection253	/// @param description Informative description of the collection254	/// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications255	/// @return address Address of the newly created collection256	#[weight(<SelfWeightOf<T>>::create_collection())]257	#[solidity(rename_selector = "createNFTCollection")]258	fn create_nft_collection(259		&mut self,260		caller: Caller,261		value: Value,262		name: String,263		description: String,264		token_prefix: String,265	) -> Result<Address> {266		let (caller, name, description, token_prefix) =267			convert_data::<T>(caller, name, description, token_prefix)?;268		let data = CreateCollectionData {269			name,270			mode: CollectionMode::NFT,271			description,272			token_prefix,273			..Default::default()274		};275		check_sent_amount_equals_collection_creation_price::<T>(value)?;276		let collection_helpers_address =277			T::CrossAccountId::from_eth(<T as pallet_common::Config>::ContractAddress::get());278		let collection_id = T::CollectionDispatch::create(caller, collection_helpers_address, data)279			.map_err(dispatch_to_evm::<T>)?;280281		let address = pallet_common::eth::collection_id_to_address(collection_id);282		Ok(address)283	}284	/// Create an NFT collection285	/// @param name Name of the collection286	/// @param description Informative description of the collection287	/// @param tokenPrefix Token prefix to represent the collection tokens in UI and user applications288	/// @return address Address of the newly created collection289	#[deprecated(note = "mathod was renamed to `create_nft_collection`, prefer it instead")]290	#[solidity(hide)]291	#[weight(<SelfWeightOf<T>>::create_collection())]292	fn create_nonfungible_collection(293		&mut self,294		caller: Caller,295		value: Value,296		name: String,297		description: String,298		token_prefix: String,299	) -> Result<Address> {300		create_collection_internal::<T>(301			caller,302			value,303			name,304			CollectionMode::NFT,305			description,306			token_prefix,307		)308	}309310	#[weight(<SelfWeightOf<T>>::create_collection())]311	#[solidity(rename_selector = "createRFTCollection")]312	fn create_rft_collection(313		&mut self,314		caller: Caller,315		value: Value,316		name: String,317		description: String,318		token_prefix: String,319	) -> Result<Address> {320		create_collection_internal::<T>(321			caller,322			value,323			name,324			CollectionMode::ReFungible,325			description,326			token_prefix,327		)328	}329330	#[weight(<SelfWeightOf<T>>::create_collection())]331	#[solidity(rename_selector = "createFTCollection")]332	fn create_fungible_collection(333		&mut self,334		caller: Caller,335		value: Value,336		name: String,337		decimals: u8,338		description: String,339		token_prefix: String,340	) -> Result<Address> {341		create_collection_internal::<T>(342			caller,343			value,344			name,345			CollectionMode::Fungible(decimals),346			description,347			token_prefix,348		)349	}350351	#[solidity(rename_selector = "makeCollectionERC721MetadataCompatible")]352	fn make_collection_metadata_compatible(353		&mut self,354		caller: Caller,355		collection: Address,356		base_uri: String,357	) -> Result<()> {358		let caller = T::CrossAccountId::from_eth(caller);359		let collection =360			pallet_common::eth::map_eth_to_id(&collection).ok_or("not a collection address")?;361		let mut collection =362			<CollectionHandle<T>>::new(collection).ok_or("collection not found")?;363364		if !matches!(365			collection.mode,366			CollectionMode::NFT | CollectionMode::ReFungible367		) {368			return Err("target collection should be either NFT or Refungible".into());369		}370371		self.recorder().consume_sstore()?;372		collection373			.check_is_owner_or_admin(&caller)374			.map_err(dispatch_to_evm::<T>)?;375376		if collection.flags.erc721metadata {377			return Err("target collection is already Erc721Metadata compatible".into());378		}379		collection.flags.erc721metadata = true;380381		let all_permissions = <pallet_common::CollectionPropertyPermissions<T>>::get(collection.id);382		if all_permissions.get(&key::url()).is_none() {383			self.recorder().consume_sstore()?;384			<PalletCommon<T>>::set_property_permission(385				&collection,386				&caller,387				up_data_structs::PropertyKeyPermission {388					key: key::url(),389					permission: up_data_structs::PropertyPermission {390						mutable: true,391						collection_admin: true,392						token_owner: false,393					},394				},395			)396			.map_err(dispatch_to_evm::<T>)?;397		}398		if all_permissions.get(&key::suffix()).is_none() {399			self.recorder().consume_sstore()?;400			<PalletCommon<T>>::set_property_permission(401				&collection,402				&caller,403				up_data_structs::PropertyKeyPermission {404					key: key::suffix(),405					permission: up_data_structs::PropertyPermission {406						mutable: true,407						collection_admin: true,408						token_owner: false,409					},410				},411			)412			.map_err(dispatch_to_evm::<T>)?;413		}414415		let all_properties = <pallet_common::CollectionProperties<T>>::get(collection.id);416		if all_properties.get(&key::base_uri()).is_none() && !base_uri.is_empty() {417			self.recorder().consume_sstore()?;418			<PalletCommon<T>>::set_collection_properties(419				&collection,420				&caller,421				[up_data_structs::Property {422					key: key::base_uri(),423					value: base_uri424						.into_bytes()425						.try_into()426						.map_err(|_| "base uri is too large")?,427				}]428				.into_iter(),429			)430			.map_err(dispatch_to_evm::<T>)?;431		}432433		self.recorder().consume_sstore()?;434		collection.save().map_err(dispatch_to_evm::<T>)?;435436		Ok(())437	}438439	#[weight(<SelfWeightOf<T>>::destroy_collection())]440	fn destroy_collection(&mut self, caller: Caller, collection_address: Address) -> Result<()> {441		let caller = T::CrossAccountId::from_eth(caller);442443		let collection_id = pallet_common::eth::map_eth_to_id(&collection_address)444			.ok_or("Invalid collection address format")?;445		<Pallet<T>>::destroy_collection_internal(caller, collection_id)446			.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)447	}448449	/// Check if a collection exists450	/// @param collectionAddress Address of the collection in question451	/// @return bool Does the collection exist?452	fn is_collection_exist(&self, _caller: Caller, collection_address: Address) -> Result<bool> {453		if let Some(id) = pallet_common::eth::map_eth_to_id(&collection_address) {454			let collection_id = id;455			return Ok(<CollectionById<T>>::contains_key(collection_id));456		}457458		Ok(false)459	}460461	fn collection_creation_fee(&self) -> Result<Value> {462		let price: u128 = T::CollectionCreationPrice::get()463			.try_into()464			.map_err(|_| ()) // workaround for `expect` requiring `Debug` trait465			.expect("Collection creation price should be convertible to u128");466		Ok(price.into())467	}468469	/// Returns address of a collection.470	/// @param collectionId  - CollectionId  of the collection471	/// @return eth mirror address of the collection472	fn collection_address(&self, collection_id: u32) -> Result<Address> {473		Ok(collection_id_to_address(collection_id.into()))474	}475476	/// Returns collectionId of a collection.477	/// @param collectionAddress  - Eth address of the collection478	/// @return collectionId of the collection479	fn collection_id(&self, collection_address: Address) -> Result<u32> {480		map_eth_to_id(&collection_address)481			.map(|id| id.0)482			.ok_or(Error::Revert(format!(483				"failed to convert address {collection_address} into collectionId."484			)))485	}486}487488/// Implements [`OnMethodCall`], which delegates call to [`EvmCollectionHelpers`]489pub struct CollectionHelpersOnMethodCall<T: Config>(PhantomData<*const T>);490impl<T: Config + pallet_nonfungible::Config + pallet_refungible::Config> OnMethodCall<T>491	for CollectionHelpersOnMethodCall<T>492where493	T::AccountId: From<[u8; 32]>,494{495	fn is_reserved(contract: &sp_core::H160) -> bool {496		contract == &T::ContractAddress::get()497	}498499	fn is_used(contract: &sp_core::H160) -> bool {500		contract == &T::ContractAddress::get()501	}502503	fn call(handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {504		if handle.code_address() != T::ContractAddress::get() {505			return None;506		}507508		let helpers =509			EvmCollectionHelpers::<T>(SubstrateRecorder::<T>::new(handle.remaining_gas()));510		pallet_evm_coder_substrate::call(handle, helpers)511	}512513	fn get_code(contract: &sp_core::H160) -> Option<Vec<u8>> {514		(contract == &T::ContractAddress::get())515			.then(|| include_bytes!("./stubs/CollectionHelpers.raw").to_vec())516	}517}518519generate_stubgen!(collection_helper_impl, CollectionHelpersCall<()>, true);520generate_stubgen!(collection_helper_iface, CollectionHelpersCall<()>, false);521522fn error_field_too_long(feild: &str, bound: usize) -> Error {523	Error::Revert(format!("{feild} is too long. Max length is {bound}."))524}