git.delta.rocks / unique-network / refs/commits / 72d79654f12f

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//! The module contains a number of functions for converting and checking ethereum identifiers.1819use alloc::format;20use sp_std::{vec, vec::Vec};21use evm_coder::{22	AbiCoder,23	types::{uint256, address},24};25pub use pallet_evm::{Config, account::CrossAccountId};26use sp_core::H160;27use up_data_structs::CollectionId;2829// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 130// TODO: Unhardcode prefix31const ETH_COLLECTION_PREFIX: [u8; 16] = [32	0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,33];3435/// Maps the ethereum address of the collection in substrate.36pub fn map_eth_to_id(eth: &H160) -> Option<CollectionId> {37	if eth[0..16] != ETH_COLLECTION_PREFIX {38		return None;39	}40	let mut id_bytes = [0; 4];41	id_bytes.copy_from_slice(&eth[16..20]);42	Some(CollectionId(u32::from_be_bytes(id_bytes)))43}4445/// Maps the substrate collection id in ethereum.46pub fn collection_id_to_address(id: CollectionId) -> H160 {47	let mut out = [0; 20];48	out[0..16].copy_from_slice(&ETH_COLLECTION_PREFIX);49	out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));50	H160(out)51}5253/// Check if the ethereum address is a collection.54pub fn is_collection(address: &H160) -> bool {55	address[0..16] == ETH_COLLECTION_PREFIX56}5758/// Convert `uint256` to `CrossAccountId`.59pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId60where61	T::AccountId: From<[u8; 32]>,62{63	let mut new_admin_arr = [0_u8; 32];64	from.to_big_endian(&mut new_admin_arr);65	let account_id = T::AccountId::from(new_admin_arr);66	T::CrossAccountId::from_sub(account_id)67}6869/// Ethereum representation of Optional value with CrossAddress.70#[derive(Debug, Default, AbiCoder)]71pub struct OptionCrossAddress {72	/// Whether or not this CrossAdress is valid and has meaning.73	pub status: bool,74	/// The underlying CrossAddress value. If the status is false, can be set to whatever.75	pub value: CrossAddress,76}7778/// Cross account struct79#[derive(Debug, Default, AbiCoder)]80pub struct CrossAddress {81	pub(crate) eth: address,82	pub(crate) sub: uint256,83}8485impl CrossAddress {86	/// Converts `CrossAccountId` to [`CrossAddress`] to be correctly usable with Ethereum.87	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self88	where89		T: pallet_evm::Config,90		T::AccountId: AsRef<[u8; 32]>,91	{92		if cross_account_id.is_canonical_substrate() {93			Self::from_sub::<T>(cross_account_id.as_sub())94		} else {95			Self {96				eth: *cross_account_id.as_eth(),97				sub: Default::default(),98			}99		}100	}101	/// Creates [`CrossAddress`] from Substrate account.102	pub fn from_sub<T>(account_id: &T::AccountId) -> Self103	where104		T: pallet_evm::Config,105		T::AccountId: AsRef<[u8; 32]>,106	{107		Self {108			eth: Default::default(),109			sub: uint256::from_big_endian(account_id.as_ref()),110		}111	}112	/// Converts [`CrossAddress`] to `CrossAccountId`.113	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>114	where115		T: pallet_evm::Config,116		T::AccountId: From<[u8; 32]>,117	{118		if self.eth == Default::default() && self.sub == Default::default() {119			Err("All fields of cross account is zeroed".into())120		} else if self.eth == Default::default() {121			Ok(convert_uint256_to_cross_account::<T>(self.sub))122		} else if self.sub == Default::default() {123			Ok(T::CrossAccountId::from_eth(self.eth))124		} else {125			Err("All fields of cross account is non zeroed".into())126		}127	}128}129130/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).131#[derive(Debug, Default, AbiCoder)]132pub struct Property {133	key: evm_coder::types::string,134	value: evm_coder::types::bytes,135}136137impl TryFrom<up_data_structs::Property> for Property {138	type Error = evm_coder::execution::Error;139140	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {141		let key = evm_coder::types::string::from_utf8(from.key.into())142			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;143		let value = evm_coder::types::bytes(from.value.to_vec());144		Ok(Property { key, value })145	}146}147148impl TryInto<up_data_structs::Property> for Property {149	type Error = evm_coder::execution::Error;150151	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {152		let key = <Vec<u8>>::from(self.key)153			.try_into()154			.map_err(|_| "key too large")?;155156		let value = self.value.0.try_into().map_err(|_| "value too large")?;157158		Ok(up_data_structs::Property { key, value })159	}160}161162/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.163#[derive(Debug, Default, Clone, Copy, AbiCoder)]164#[repr(u8)]165pub enum CollectionLimitField {166	/// How many tokens can a user have on one account.167	#[default]168	AccountTokenOwnership,169170	/// How many bytes of data are available for sponsorship.171	SponsoredDataSize,172173	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]174	SponsoredDataRateLimit,175176	/// How many tokens can be mined into this collection.177	TokenLimit,178179	/// Timeouts for transfer sponsoring.180	SponsorTransferTimeout,181182	/// Timeout for sponsoring an approval in passed blocks.183	SponsorApproveTimeout,184185	/// Whether the collection owner of the collection can send tokens (which belong to other users).186	OwnerCanTransfer,187188	/// Can the collection owner burn other people's tokens.189	OwnerCanDestroy,190191	/// Is it possible to send tokens from this collection between users.192	TransferEnabled,193}194195/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.196#[derive(Debug, Default, AbiCoder)]197pub struct CollectionLimit {198	field: CollectionLimitField,199	value: Option<uint256>,200}201202impl CollectionLimit {203	/// Create [`CollectionLimit`] from field and value.204	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {205		Self {206			field,207			value: match value {208				Some(value) => Some(value.into()),209				None => None,210			},211		}212	}213	/// Whether the field contains a value.214	pub fn has_value(&self) -> bool {215		self.value.is_some()216	}217}218219impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {220	type Error = evm_coder::execution::Error;221222	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {223		let value = self224			.value225			.ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;226		let value = Some(value.try_into().map_err(|error| {227			Self::Error::Revert(format!(228				"can't convert value to u32 \"{}\" because: \"{error}\"",229				value230			))231		})?);232233		let convert_value_to_bool = || match value {234			Some(value) => match value {235				0 => Ok(Some(false)),236				1 => Ok(Some(true)),237				_ => {238					return Err(Self::Error::Revert(format!(239						"can't convert value to boolean \"{value}\""240					)))241				}242			},243			None => Ok(None),244		};245246		let mut limits = up_data_structs::CollectionLimits::default();247		match self.field {248			CollectionLimitField::AccountTokenOwnership => {249				limits.account_token_ownership_limit = value;250			}251			CollectionLimitField::SponsoredDataSize => {252				limits.sponsored_data_size = value;253			}254			CollectionLimitField::SponsoredDataRateLimit => {255				limits.sponsored_data_rate_limit = match value {256					Some(value) => Some(up_data_structs::SponsoringRateLimit::Blocks(value)),257					None => None,258				};259			}260			CollectionLimitField::TokenLimit => {261				limits.token_limit = value;262			}263			CollectionLimitField::SponsorTransferTimeout => {264				limits.sponsor_transfer_timeout = value;265			}266			CollectionLimitField::SponsorApproveTimeout => {267				limits.sponsor_approve_timeout = value;268			}269			CollectionLimitField::OwnerCanTransfer => {270				limits.owner_can_transfer = convert_value_to_bool()?;271			}272			CollectionLimitField::OwnerCanDestroy => {273				limits.owner_can_destroy = convert_value_to_bool()?;274			}275			CollectionLimitField::TransferEnabled => {276				limits.transfers_enabled = convert_value_to_bool()?;277			}278		};279		Ok(limits)280	}281}282283/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.284#[derive(Default, Debug, Clone, Copy, AbiCoder)]285#[repr(u8)]286pub enum CollectionPermissionField {287	/// Owner of token can nest tokens under it.288	#[default]289	TokenOwner,290291	/// Admin of token collection can nest tokens under token.292	CollectionAdmin,293}294295/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.296#[derive(AbiCoder, Copy, Clone, Default, Debug)]297#[repr(u8)]298pub enum TokenPermissionField {299	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]300	#[default]301	Mutable,302303	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]304	TokenOwner,305306	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]307	CollectionAdmin,308}309310/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.311#[derive(Debug, Default, AbiCoder)]312pub struct PropertyPermission {313	/// TokenPermission field.314	code: TokenPermissionField,315	/// TokenPermission value.316	value: bool,317}318319impl PropertyPermission {320	/// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].321	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {322		vec![323			PropertyPermission {324				code: TokenPermissionField::Mutable,325				value: pp.mutable,326			},327			PropertyPermission {328				code: TokenPermissionField::TokenOwner,329				value: pp.token_owner,330			},331			PropertyPermission {332				code: TokenPermissionField::CollectionAdmin,333				value: pp.collection_admin,334			},335		]336	}337338	/// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].339	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {340		let mut token_permission = up_data_structs::PropertyPermission::default();341342		for PropertyPermission { code, value } in permission {343			match code {344				TokenPermissionField::Mutable => token_permission.mutable = value,345				TokenPermissionField::TokenOwner => token_permission.token_owner = value,346				TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,347			}348		}349		token_permission350	}351}352353/// Ethereum representation of Token Property Permissions.354#[derive(Debug, Default, AbiCoder)]355pub struct TokenPropertyPermission {356	/// Token property key.357	key: evm_coder::types::string,358	/// Token property permissions.359	permissions: Vec<PropertyPermission>,360}361362impl363	From<(364		up_data_structs::PropertyKey,365		up_data_structs::PropertyPermission,366	)> for TokenPropertyPermission367{368	fn from(369		value: (370			up_data_structs::PropertyKey,371			up_data_structs::PropertyPermission,372		),373	) -> Self {374		let (key, permission) = value;375		let key = evm_coder::types::string::from_utf8(key.into_inner())376			.expect("Stored key must be valid");377		let permissions = PropertyPermission::into_vec(permission);378		Self { key, permissions }379	}380}381382impl TokenPropertyPermission {383	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].384	pub fn into_property_key_permissions(385		permissions: Vec<TokenPropertyPermission>,386	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {387		let mut perms = Vec::new();388389		for TokenPropertyPermission { key, permissions } in permissions {390			let token_permission = PropertyPermission::from_vec(permissions);391392			perms.push(up_data_structs::PropertyKeyPermission {393				key: key.into_bytes().try_into().map_err(|_| "too long key")?,394				permission: token_permission,395			});396		}397		Ok(perms)398	}399}400401/// Nested collections.402#[derive(Debug, Default, AbiCoder)]403pub struct CollectionNesting {404	token_owner: bool,405	ids: Vec<uint256>,406}407408impl CollectionNesting {409	/// Create [`CollectionNesting`].410	pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {411		Self { token_owner, ids }412	}413}414415/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.416#[derive(Debug, Default, AbiCoder)]417pub struct CollectionNestingPermission {418	field: CollectionPermissionField,419	value: bool,420}421422impl CollectionNestingPermission {423	/// Create [`CollectionNestingPermission`].424	pub fn new(field: CollectionPermissionField, value: bool) -> Self {425		Self { field, value }426	}427}