git.delta.rocks / unique-network / refs/commits / 0f81eccfefee

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.1819pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId};20use evm_coder::{21	abi::AbiType,22	solidity_interface, solidity, ToLog,23	types::*,24	types::Property as PropertyStruct,25	execution::{Result, Error},26	weight,27};28use pallet_evm_coder_substrate::dispatch_to_evm;29use sp_std::vec::Vec;30use up_data_structs::{31	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,32	SponsoringRateLimit, SponsorshipState,33};34use alloc::format;3536use crate::{37	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,38	eth::{EthCrossAccount, convert_cross_account_to_uint256},39	weights::WeightInfo,40};4142/// Events for ethereum collection helper.43#[derive(ToLog)]44pub enum CollectionHelpersEvents {45	/// The collection has been created.46	CollectionCreated {47		/// Collection owner.48		#[indexed]49		owner: address,5051		/// Collection ID.52		#[indexed]53		collection_id: address,54	},55	/// The collection has been destroyed.56	CollectionDestroyed {57		/// Collection ID.58		#[indexed]59		collection_id: address,60	},61}6263/// Does not always represent a full collection, for RFT it is either64/// collection (Implementing ERC721), or specific collection token (Implementing ERC20).65pub trait CommonEvmHandler {66	/// Raw compiled binary code of the contract stub67	const CODE: &'static [u8];6869	/// Call precompiled handle.70	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult>;71}7273/// @title A contract that allows you to work with collections.74#[solidity_interface(name = Collection)]75impl<T: Config> CollectionHandle<T>76where77	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,78{79	/// Set collection property.80	///81	/// @param key Property key.82	/// @param value Propery value.83	#[solidity(hide)]84	#[weight(<SelfWeightOf<T>>::set_collection_properties(1))]85	fn set_collection_property(86		&mut self,87		caller: caller,88		key: string,89		value: bytes,90	) -> Result<void> {91		let caller = T::CrossAccountId::from_eth(caller);92		let key = <Vec<u8>>::from(key)93			.try_into()94			.map_err(|_| "key too large")?;95		let value = value.0.try_into().map_err(|_| "value too large")?;9697		<Pallet<T>>::set_collection_property(self, &caller, Property { key, value })98			.map_err(dispatch_to_evm::<T>)99	}100101	/// Set collection properties.102	///103	/// @param properties Vector of properties key/value pair.104	#[weight(<SelfWeightOf<T>>::set_collection_properties(properties.len() as u32))]105	fn set_collection_properties(106		&mut self,107		caller: caller,108		properties: Vec<PropertyStruct>,109	) -> Result<void> {110		let caller = T::CrossAccountId::from_eth(caller);111112		let properties = properties113			.into_iter()114			.map(|PropertyStruct { key, value }| {115				let key = <Vec<u8>>::from(key)116					.try_into()117					.map_err(|_| "key too large")?;118119				let value = value.0.try_into().map_err(|_| "value too large")?;120121				Ok(Property { key, value })122			})123			.collect::<Result<Vec<_>>>()?;124125		<Pallet<T>>::set_collection_properties(self, &caller, properties)126			.map_err(dispatch_to_evm::<T>)127	}128129	/// Delete collection property.130	///131	/// @param key Property key.132	#[solidity(hide)]133	#[weight(<SelfWeightOf<T>>::delete_collection_properties(1))]134	fn delete_collection_property(&mut self, caller: caller, key: string) -> Result<()> {135		let caller = T::CrossAccountId::from_eth(caller);136		let key = <Vec<u8>>::from(key)137			.try_into()138			.map_err(|_| "key too large")?;139140		<Pallet<T>>::delete_collection_property(self, &caller, key).map_err(dispatch_to_evm::<T>)141	}142143	/// Delete collection properties.144	///145	/// @param keys Properties keys.146	#[weight(<SelfWeightOf<T>>::delete_collection_properties(keys.len() as u32))]147	fn delete_collection_properties(&mut self, caller: caller, keys: Vec<string>) -> Result<()> {148		let caller = T::CrossAccountId::from_eth(caller);149		let keys = keys150			.into_iter()151			.map(|key| {152				<Vec<u8>>::from(key)153					.try_into()154					.map_err(|_| Error::Revert("key too large".into()))155			})156			.collect::<Result<Vec<_>>>()?;157158		<Pallet<T>>::delete_collection_properties(self, &caller, keys).map_err(dispatch_to_evm::<T>)159	}160161	/// Get collection property.162	///163	/// @dev Throws error if key not found.164	///165	/// @param key Property key.166	/// @return bytes The property corresponding to the key.167	fn collection_property(&self, key: string) -> Result<bytes> {168		let key = <Vec<u8>>::from(key)169			.try_into()170			.map_err(|_| "key too large")?;171172		let props = CollectionProperties::<T>::get(self.id);173		let prop = props.get(&key).ok_or("key not found")?;174175		Ok(bytes(prop.to_vec()))176	}177178	/// Get collection properties.179	///180	/// @param keys Properties keys. Empty keys for all propertyes.181	/// @return Vector of properties key/value pairs.182	fn collection_properties(&self, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {183		let keys = keys184			.into_iter()185			.map(|key| {186				<Vec<u8>>::from(key)187					.try_into()188					.map_err(|_| Error::Revert("key too large".into()))189			})190			.collect::<Result<Vec<_>>>()?;191192		let properties = Pallet::<T>::filter_collection_properties(193			self.id,194			if keys.is_empty() { None } else { Some(keys) },195		)196		.map_err(dispatch_to_evm::<T>)?;197198		let properties = properties199			.into_iter()200			.map(|p| {201				let key =202					string::from_utf8(p.key.into()).map_err(|e| Error::Revert(format!("{}", e)))?;203				let value = bytes(p.value.to_vec());204				Ok(PropertyStruct { key, value })205			})206			.collect::<Result<Vec<_>>>()?;207		Ok(properties)208	}209210	/// Set the sponsor of the collection.211	///212	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.213	///214	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.215	#[solidity(hide)]216	fn set_collection_sponsor(&mut self, caller: caller, sponsor: address) -> Result<void> {217		self.consume_store_reads_and_writes(1, 1)?;218219		check_is_owner_or_admin(caller, self)?;220221		let sponsor = T::CrossAccountId::from_eth(sponsor);222		self.set_sponsor(sponsor.as_sub().clone())223			.map_err(dispatch_to_evm::<T>)?;224		save(self)225	}226227	/// Set the sponsor of the collection.228	///229	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.230	///231	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.232	fn set_collection_sponsor_cross(233		&mut self,234		caller: caller,235		sponsor: EthCrossAccount,236	) -> Result<void> {237		self.consume_store_reads_and_writes(1, 1)?;238239		check_is_owner_or_admin(caller, self)?;240241		let sponsor = sponsor.into_sub_cross_account::<T>()?;242		self.set_sponsor(sponsor.as_sub().clone())243			.map_err(dispatch_to_evm::<T>)?;244		save(self)245	}246247	/// Whether there is a pending sponsor.248	fn has_collection_pending_sponsor(&self) -> Result<bool> {249		Ok(matches!(250			self.collection.sponsorship,251			SponsorshipState::Unconfirmed(_)252		))253	}254255	/// Collection sponsorship confirmation.256	///257	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.258	fn confirm_collection_sponsorship(&mut self, caller: caller) -> Result<void> {259		self.consume_store_writes(1)?;260261		let caller = T::CrossAccountId::from_eth(caller);262		if !self263			.confirm_sponsorship(caller.as_sub())264			.map_err(dispatch_to_evm::<T>)?265		{266			return Err("caller is not set as sponsor".into());267		}268		save(self)269	}270271	/// Remove collection sponsor.272	fn remove_collection_sponsor(&mut self, caller: caller) -> Result<void> {273		self.consume_store_reads_and_writes(1, 1)?;274		check_is_owner_or_admin(caller, self)?;275		self.remove_sponsor().map_err(dispatch_to_evm::<T>)?;276		save(self)277	}278279	/// Get current sponsor.280	///281	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.282	fn collection_sponsor(&self) -> Result<(address, uint256)> {283		let sponsor = match self.collection.sponsorship.sponsor() {284			Some(sponsor) => sponsor,285			None => return Ok(Default::default()),286		};287		let sponsor = T::CrossAccountId::from_sub(sponsor.clone());288		let result: (address, uint256) = if sponsor.is_canonical_substrate() {289			let sponsor = convert_cross_account_to_uint256::<T>(&sponsor);290			(Default::default(), sponsor)291		} else {292			let sponsor = *sponsor.as_eth();293			(sponsor, Default::default())294		};295		Ok(result)296	}297298	/// Set limits for the collection.299	/// @dev Throws error if limit not found.300	/// @param limit Name of the limit. Valid names:301	/// 	"accountTokenOwnershipLimit",302	/// 	"sponsoredDataSize",303	/// 	"sponsoredDataRateLimit",304	/// 	"tokenLimit",305	/// 	"sponsorTransferTimeout",306	/// 	"sponsorApproveTimeout"307	///  	"ownerCanTransfer",308	/// 	"ownerCanDestroy",309	/// 	"transfersEnabled"310	/// @param value Value of the limit.311	#[solidity(rename_selector = "setCollectionLimit")]312	fn set_int_limit(&mut self, caller: caller, limit: string, value: uint256) -> Result<void> {313		self.consume_store_reads_and_writes(1, 1)?;314315		let value = value316			.try_into()317			.map_err(|_| Error::Revert(format!("can't convert value to u32 \"{}\"", value)))?;318319		let convert_value_to_bool = || match value {320			0 => Ok(false),321			1 => Ok(true),322			_ => {323				return Err(Error::Revert(format!(324					"can't convert value to boolean \"{}\"",325					value326				)))327			}328		};329330		check_is_owner_or_admin(caller, self)?;331		let mut limits = self.limits.clone();332333		match limit.as_str() {334			"accountTokenOwnershipLimit" => {335				limits.account_token_ownership_limit = Some(value);336			}337			"sponsoredDataSize" => {338				limits.sponsored_data_size = Some(value);339			}340			"sponsoredDataRateLimit" => {341				limits.sponsored_data_rate_limit = Some(SponsoringRateLimit::Blocks(value));342			}343			"tokenLimit" => {344				limits.token_limit = Some(value);345			}346			"sponsorTransferTimeout" => {347				limits.sponsor_transfer_timeout = Some(value);348			}349			"sponsorApproveTimeout" => {350				limits.sponsor_approve_timeout = Some(value);351			}352			"ownerCanTransfer" => {353				limits.owner_can_transfer = Some(convert_value_to_bool()?);354			}355			"ownerCanDestroy" => {356				limits.owner_can_destroy = Some(convert_value_to_bool()?);357			}358			"transfersEnabled" => {359				limits.transfers_enabled = Some(convert_value_to_bool()?);360			}361			_ => return Err(Error::Revert(format!("unknown limit \"{}\"", limit))),362		}363		self.limits = <Pallet<T>>::clamp_limits(self.mode.clone(), &self.limits, limits)364			.map_err(dispatch_to_evm::<T>)?;365		save(self)366	}367368	/// Get contract address.369	fn contract_address(&self) -> Result<address> {370		Ok(crate::eth::collection_id_to_address(self.id))371	}372373	/// Add collection admin.374	/// @param newAdmin Cross account administrator address.375	fn add_collection_admin_cross(376		&mut self,377		caller: caller,378		new_admin: EthCrossAccount,379	) -> Result<void> {380		self.consume_store_writes(2)?;381382		let caller = T::CrossAccountId::from_eth(caller);383		let new_admin = new_admin.into_sub_cross_account::<T>()?;384		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;385		Ok(())386	}387388	/// Remove collection admin.389	/// @param admin Cross account administrator address.390	fn remove_collection_admin_cross(391		&mut self,392		caller: caller,393		admin: EthCrossAccount,394	) -> Result<void> {395		self.consume_store_writes(2)?;396397		let caller = T::CrossAccountId::from_eth(caller);398		let admin = admin.into_sub_cross_account::<T>()?;399		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;400		Ok(())401	}402403	/// Add collection admin.404	/// @param newAdmin Address of the added administrator.405	#[solidity(hide)]406	fn add_collection_admin(&mut self, caller: caller, new_admin: address) -> Result<void> {407		self.consume_store_writes(2)?;408409		let caller = T::CrossAccountId::from_eth(caller);410		let new_admin = T::CrossAccountId::from_eth(new_admin);411		<Pallet<T>>::toggle_admin(self, &caller, &new_admin, true).map_err(dispatch_to_evm::<T>)?;412		Ok(())413	}414415	/// Remove collection admin.416	///417	/// @param admin Address of the removed administrator.418	#[solidity(hide)]419	fn remove_collection_admin(&mut self, caller: caller, admin: address) -> Result<void> {420		self.consume_store_writes(2)?;421422		let caller = T::CrossAccountId::from_eth(caller);423		let admin = T::CrossAccountId::from_eth(admin);424		<Pallet<T>>::toggle_admin(self, &caller, &admin, false).map_err(dispatch_to_evm::<T>)?;425		Ok(())426	}427428	/// Toggle accessibility of collection nesting.429	///430	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'431	#[solidity(rename_selector = "setCollectionNesting")]432	fn set_nesting_bool(&mut self, caller: caller, enable: bool) -> Result<void> {433		self.consume_store_reads_and_writes(1, 1)?;434435		check_is_owner_or_admin(caller, self)?;436437		let mut permissions = self.collection.permissions.clone();438		let mut nesting = permissions.nesting().clone();439		nesting.token_owner = enable;440		nesting.restricted = None;441		permissions.nesting = Some(nesting);442443		self.collection.permissions = <Pallet<T>>::clamp_permissions(444			self.collection.mode.clone(),445			&self.collection.permissions,446			permissions,447		)448		.map_err(dispatch_to_evm::<T>)?;449450		save(self)451	}452453	/// Toggle accessibility of collection nesting.454	///455	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'456	/// @param collections Addresses of collections that will be available for nesting.457	#[solidity(rename_selector = "setCollectionNesting")]458	fn set_nesting(459		&mut self,460		caller: caller,461		enable: bool,462		collections: Vec<address>,463	) -> Result<void> {464		self.consume_store_reads_and_writes(1, 1)?;465466		if collections.is_empty() {467			return Err("no addresses provided".into());468		}469		check_is_owner_or_admin(caller, self)?;470471		let mut permissions = self.collection.permissions.clone();472		match enable {473			false => {474				let mut nesting = permissions.nesting().clone();475				nesting.token_owner = false;476				nesting.restricted = None;477				permissions.nesting = Some(nesting);478			}479			true => {480				let mut bv = OwnerRestrictedSet::new();481				for i in collections {482					bv.try_insert(crate::eth::map_eth_to_id(&i).ok_or_else(|| {483						Error::Revert("Can't convert address into collection id".into())484					})?)485					.map_err(|_| "too many collections")?;486				}487				let mut nesting = permissions.nesting().clone();488				nesting.token_owner = true;489				nesting.restricted = Some(bv);490				permissions.nesting = Some(nesting);491			}492		};493494		self.collection.permissions = <Pallet<T>>::clamp_permissions(495			self.collection.mode.clone(),496			&self.collection.permissions,497			permissions,498		)499		.map_err(dispatch_to_evm::<T>)?;500501		save(self)502	}503504	/// Set the collection access method.505	/// @param mode Access mode506	/// 	0 for Normal507	/// 	1 for AllowList508	fn set_collection_access(&mut self, caller: caller, mode: uint8) -> Result<void> {509		self.consume_store_reads_and_writes(1, 1)?;510511		check_is_owner_or_admin(caller, self)?;512		let permissions = CollectionPermissions {513			access: Some(match mode {514				0 => AccessMode::Normal,515				1 => AccessMode::AllowList,516				_ => return Err("not supported access mode".into()),517			}),518			..Default::default()519		};520		self.collection.permissions = <Pallet<T>>::clamp_permissions(521			self.collection.mode.clone(),522			&self.collection.permissions,523			permissions,524		)525		.map_err(dispatch_to_evm::<T>)?;526527		save(self)528	}529530	/// Checks that user allowed to operate with collection.531	///532	/// @param user User address to check.533	fn allowlisted_cross(&self, user: EthCrossAccount) -> Result<bool> {534		let user = user.into_sub_cross_account::<T>()?;535		Ok(Pallet::<T>::allowed(self.id, user))536	}537538	/// Add the user to the allowed list.539	///540	/// @param user Address of a trusted user.541	#[solidity(hide)]542	fn add_to_collection_allow_list(&mut self, caller: caller, user: address) -> Result<void> {543		self.consume_store_writes(1)?;544545		let caller = T::CrossAccountId::from_eth(caller);546		let user = T::CrossAccountId::from_eth(user);547		<Pallet<T>>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;548		Ok(())549	}550551	/// Add user to allowed list.552	///553	/// @param user User cross account address.554	fn add_to_collection_allow_list_cross(555		&mut self,556		caller: caller,557		user: EthCrossAccount,558	) -> Result<void> {559		self.consume_store_writes(1)?;560561		let caller = T::CrossAccountId::from_eth(caller);562		let user = user.into_sub_cross_account::<T>()?;563		Pallet::<T>::toggle_allowlist(self, &caller, &user, true).map_err(dispatch_to_evm::<T>)?;564		Ok(())565	}566567	/// Remove the user from the allowed list.568	///569	/// @param user Address of a removed user.570	#[solidity(hide)]571	fn remove_from_collection_allow_list(&mut self, caller: caller, user: address) -> Result<void> {572		self.consume_store_writes(1)?;573574		let caller = T::CrossAccountId::from_eth(caller);575		let user = T::CrossAccountId::from_eth(user);576		<Pallet<T>>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;577		Ok(())578	}579580	/// Remove user from allowed list.581	///582	/// @param user User cross account address.583	fn remove_from_collection_allow_list_cross(584		&mut self,585		caller: caller,586		user: EthCrossAccount,587	) -> Result<void> {588		self.consume_store_writes(1)?;589590		let caller = T::CrossAccountId::from_eth(caller);591		let user = user.into_sub_cross_account::<T>()?;592		Pallet::<T>::toggle_allowlist(self, &caller, &user, false).map_err(dispatch_to_evm::<T>)?;593		Ok(())594	}595596	/// Switch permission for minting.597	///598	/// @param mode Enable if "true".599	fn set_collection_mint_mode(&mut self, caller: caller, mode: bool) -> Result<void> {600		self.consume_store_reads_and_writes(1, 1)?;601602		check_is_owner_or_admin(caller, self)?;603		let permissions = CollectionPermissions {604			mint_mode: Some(mode),605			..Default::default()606		};607		self.collection.permissions = <Pallet<T>>::clamp_permissions(608			self.collection.mode.clone(),609			&self.collection.permissions,610			permissions,611		)612		.map_err(dispatch_to_evm::<T>)?;613614		save(self)615	}616617	/// Check that account is the owner or admin of the collection618	///619	/// @param user account to verify620	/// @return "true" if account is the owner or admin621	#[solidity(hide, rename_selector = "isOwnerOrAdmin")]622	fn is_owner_or_admin_eth(&self, user: address) -> Result<bool> {623		let user = T::CrossAccountId::from_eth(user);624		Ok(self.is_owner_or_admin(&user))625	}626627	/// Check that account is the owner or admin of the collection628	///629	/// @param user User cross account to verify630	/// @return "true" if account is the owner or admin631	fn is_owner_or_admin_cross(&self, user: EthCrossAccount) -> Result<bool> {632		let user = user.into_sub_cross_account::<T>()?;633		Ok(self.is_owner_or_admin(&user))634	}635636	/// Returns collection type637	///638	/// @return `Fungible` or `NFT` or `ReFungible`639	fn unique_collection_type(&self) -> Result<string> {640		let mode = match self.collection.mode {641			CollectionMode::Fungible(_) => "Fungible",642			CollectionMode::NFT => "NFT",643			CollectionMode::ReFungible => "ReFungible",644		};645		Ok(mode.into())646	}647648	/// Get collection owner.649	///650	/// @return Tuble with sponsor address and his substrate mirror.651	/// If address is canonical then substrate mirror is zero and vice versa.652	fn collection_owner(&self) -> Result<EthCrossAccount> {653		Ok(EthCrossAccount::from_sub_cross_account::<T>(654			&T::CrossAccountId::from_sub(self.owner.clone()),655		))656	}657658	/// Changes collection owner to another account659	///660	/// @dev Owner can be changed only by current owner661	/// @param newOwner new owner account662	#[solidity(hide, rename_selector = "changeCollectionOwner")]663	fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<void> {664		self.consume_store_writes(1)?;665666		let caller = T::CrossAccountId::from_eth(caller);667		let new_owner = T::CrossAccountId::from_eth(new_owner);668		self.set_owner_internal(caller, new_owner)669			.map_err(dispatch_to_evm::<T>)670	}671672	/// Get collection administrators673	///674	/// @return Vector of tuples with admins address and his substrate mirror.675	/// If address is canonical then substrate mirror is zero and vice versa.676	fn collection_admins(&self) -> Result<Vec<EthCrossAccount>> {677		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))678			.map(|(admin, _)| EthCrossAccount::from_sub_cross_account::<T>(&admin))679			.collect();680		Ok(result)681	}682683	/// Changes collection owner to another account684	///685	/// @dev Owner can be changed only by current owner686	/// @param newOwner new owner cross account687	fn change_collection_owner_cross(688		&mut self,689		caller: caller,690		new_owner: EthCrossAccount,691	) -> Result<void> {692		self.consume_store_writes(1)?;693694		let caller = T::CrossAccountId::from_eth(caller);695		let new_owner = new_owner.into_sub_cross_account::<T>()?;696		self.set_owner_internal(caller, new_owner)697			.map_err(dispatch_to_evm::<T>)698	}699}700701/// ### Note702/// Do not forget to add: `self.consume_store_reads(1)?;`703fn check_is_owner_or_admin<T: Config>(704	caller: caller,705	collection: &CollectionHandle<T>,706) -> Result<T::CrossAccountId> {707	let caller = T::CrossAccountId::from_eth(caller);708	collection709		.check_is_owner_or_admin(&caller)710		.map_err(dispatch_to_evm::<T>)?;711	Ok(caller)712}713714/// ### Note715/// Do not forget to add: `self.consume_store_writes(1)?;`716fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {717	collection718		.check_is_internal()719		.map_err(dispatch_to_evm::<T>)?;720	collection.save().map_err(dispatch_to_evm::<T>)?;721	Ok(())722}723724/// Contains static property keys and values.725pub mod static_property {726	use evm_coder::{727		execution::{Result, Error},728	};729	use alloc::format;730731	const EXPECT_CONVERT_ERROR: &str = "length < limit";732733	/// Keys.734	pub mod key {735		use super::*;736737		/// Key "baseURI".738		pub fn base_uri() -> up_data_structs::PropertyKey {739			property_key_from_bytes(b"baseURI").expect(EXPECT_CONVERT_ERROR)740		}741742		/// Key "url".743		pub fn url() -> up_data_structs::PropertyKey {744			property_key_from_bytes(b"URI").expect(EXPECT_CONVERT_ERROR)745		}746747		/// Key "suffix".748		pub fn suffix() -> up_data_structs::PropertyKey {749			property_key_from_bytes(b"URISuffix").expect(EXPECT_CONVERT_ERROR)750		}751752		/// Key "parentNft".753		pub fn parent_nft() -> up_data_structs::PropertyKey {754			property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR)755		}756	}757758	/// Convert `byte` to [`PropertyKey`].759	pub fn property_key_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyKey> {760		bytes.to_vec().try_into().map_err(|_| {761			Error::Revert(format!(762				"Property key is too long. Max length is {}.",763				up_data_structs::PropertyKey::bound()764			))765		})766	}767768	/// Convert `bytes` to [`PropertyValue`].769	pub fn property_value_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyValue> {770		bytes.to_vec().try_into().map_err(|_| {771			Error::Revert(format!(772				"Property key is too long. Max length is {}.",773				up_data_structs::PropertyKey::bound()774			))775		})776	}777}