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

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 uint256.70#[derive(Debug, Default, AbiCoder)]71pub struct OptionUint {72	status: bool,73	value: uint256,74}7576impl From<u32> for OptionUint {77	fn from(value: u32) -> Self {78		Self {79			status: true,80			value: uint256::from(value),81		}82	}83}8485impl From<Option<u32>> for OptionUint {86	fn from(value: Option<u32>) -> Self {87		match value {88			Some(value) => Self {89				status: true,90				value: value.into(),91			},92			None => Self {93				status: false,94				value: Default::default(),95			},96		}97	}98}99100impl From<Option<bool>> for OptionUint {101	fn from(value: Option<bool>) -> Self {102		match value {103			Some(value) => Self {104				status: true,105				value: if value {106					uint256::from(1)107				} else {108					Default::default()109				},110			},111			None => Self {112				status: false,113				value: Default::default(),114			},115		}116	}117}118119/// Cross account struct120#[derive(Debug, Default, AbiCoder)]121pub struct CrossAddress {122	pub(crate) eth: address,123	pub(crate) sub: uint256,124}125126impl CrossAddress {127	/// Converts `CrossAccountId` to [`CrossAddress`]128	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self129	where130		T: pallet_evm::Config,131		T::AccountId: AsRef<[u8; 32]>,132	{133		if cross_account_id.is_canonical_substrate() {134			Self::from_sub::<T>(cross_account_id.as_sub())135		} else {136			Self {137				eth: *cross_account_id.as_eth(),138				sub: Default::default(),139			}140		}141	}142	/// Creates [`CrossAddress`] from substrate account143	pub fn from_sub<T>(account_id: &T::AccountId) -> Self144	where145		T: pallet_evm::Config,146		T::AccountId: AsRef<[u8; 32]>,147	{148		Self {149			eth: Default::default(),150			sub: uint256::from_big_endian(account_id.as_ref()),151		}152	}153	/// Converts [`CrossAddress`] to `CrossAccountId`154	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>155	where156		T: pallet_evm::Config,157		T::AccountId: From<[u8; 32]>,158	{159		if self.eth == Default::default() && self.sub == Default::default() {160			Err("All fields of cross account is zeroed".into())161		} else if self.eth == Default::default() {162			Ok(convert_uint256_to_cross_account::<T>(self.sub))163		} else if self.sub == Default::default() {164			Ok(T::CrossAccountId::from_eth(self.eth))165		} else {166			Err("All fields of cross account is non zeroed".into())167		}168	}169}170171/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).172#[derive(Debug, Default, AbiCoder)]173pub struct Property {174	key: evm_coder::types::string,175	value: evm_coder::types::bytes,176}177178impl TryFrom<up_data_structs::Property> for Property {179	type Error = evm_coder::execution::Error;180181	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {182		let key = evm_coder::types::string::from_utf8(from.key.into())183			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;184		let value = evm_coder::types::bytes(from.value.to_vec());185		Ok(Property { key, value })186	}187}188189impl TryInto<up_data_structs::Property> for Property {190	type Error = evm_coder::execution::Error;191192	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {193		let key = <Vec<u8>>::from(self.key)194			.try_into()195			.map_err(|_| "key too large")?;196197		let value = self.value.0.try_into().map_err(|_| "value too large")?;198199		Ok(up_data_structs::Property { key, value })200	}201}202203/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.204#[derive(Debug, Default, Clone, Copy, AbiCoder)]205#[repr(u8)]206pub enum CollectionLimitField {207	/// How many tokens can a user have on one account.208	#[default]209	AccountTokenOwnership,210211	/// How many bytes of data are available for sponsorship.212	SponsoredDataSize,213214	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]215	SponsoredDataRateLimit,216217	/// How many tokens can be mined into this collection.218	TokenLimit,219220	/// Timeouts for transfer sponsoring.221	SponsorTransferTimeout,222223	/// Timeout for sponsoring an approval in passed blocks.224	SponsorApproveTimeout,225226	/// Whether the collection owner of the collection can send tokens (which belong to other users).227	OwnerCanTransfer,228229	/// Can the collection owner burn other people's tokens.230	OwnerCanDestroy,231232	/// Is it possible to send tokens from this collection between users.233	TransferEnabled,234}235236/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.237#[derive(Debug, Default, AbiCoder)]238pub struct CollectionLimit {239	field: CollectionLimitField,240	value: OptionUint,241}242243impl CollectionLimit {244	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and int value.245	pub fn from_int(field: CollectionLimitField, value: u32) -> Self {246		Self {247			field,248			value: value.into(),249		}250	}251252	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and optional int value.253	pub fn from_opt_int(field: CollectionLimitField, value: Option<u32>) -> Self {254		Self {255			field,256			value: value.into(),257		}258	}259260	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and bool value.261	pub fn from_opt_bool(field: CollectionLimitField, value: Option<bool>) -> Self {262		Self {263			field,264			value: value.into(),265		}266	}267}268269impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {270	type Error = evm_coder::execution::Error;271272	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {273		if !self.value.status {274			return Err(Self::Error::Revert("user can't disable limits".into()));275		}276277		let value = self.value.value.try_into().map_err(|error| {278			Self::Error::Revert(format!(279				"can't convert value to u32 \"{}\" because: \"{error}\"",280				self.value.value281			))282		})?;283284		let convert_value_to_bool = || match value {285			0 => Ok(false),286			1 => Ok(true),287			_ => {288				return Err(Self::Error::Revert(format!(289					"can't convert value to boolean \"{value}\""290				)))291			}292		};293294		let mut limits = up_data_structs::CollectionLimits::default();295		match self.field {296			CollectionLimitField::AccountTokenOwnership => {297				limits.account_token_ownership_limit = Some(value);298			}299			CollectionLimitField::SponsoredDataSize => {300				limits.sponsored_data_size = Some(value);301			}302			CollectionLimitField::SponsoredDataRateLimit => {303				limits.sponsored_data_rate_limit =304					Some(up_data_structs::SponsoringRateLimit::Blocks(value));305			}306			CollectionLimitField::TokenLimit => {307				limits.token_limit = Some(value);308			}309			CollectionLimitField::SponsorTransferTimeout => {310				limits.sponsor_transfer_timeout = Some(value);311			}312			CollectionLimitField::SponsorApproveTimeout => {313				limits.sponsor_approve_timeout = Some(value);314			}315			CollectionLimitField::OwnerCanTransfer => {316				limits.owner_can_transfer = Some(convert_value_to_bool()?);317			}318			CollectionLimitField::OwnerCanDestroy => {319				limits.owner_can_destroy = Some(convert_value_to_bool()?);320			}321			CollectionLimitField::TransferEnabled => {322				limits.transfers_enabled = Some(convert_value_to_bool()?);323			}324		};325		Ok(limits)326	}327}328329/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.330#[derive(Default, Debug, Clone, Copy, AbiCoder)]331#[repr(u8)]332pub enum CollectionPermissionField {333	/// Owner of token can nest tokens under it.334	#[default]335	TokenOwner,336337	/// Admin of token collection can nest tokens under token.338	CollectionAdmin,339}340341/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.342#[derive(AbiCoder, Copy, Clone, Default, Debug)]343#[repr(u8)]344pub enum TokenPermissionField {345	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]346	#[default]347	Mutable,348349	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]350	TokenOwner,351352	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]353	CollectionAdmin,354}355356/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.357#[derive(Debug, Default, AbiCoder)]358pub struct PropertyPermission {359	/// TokenPermission field.360	code: TokenPermissionField,361	/// TokenPermission value.362	value: bool,363}364365impl PropertyPermission {366	/// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].367	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {368		vec![369			PropertyPermission {370				code: TokenPermissionField::Mutable,371				value: pp.mutable,372			},373			PropertyPermission {374				code: TokenPermissionField::TokenOwner,375				value: pp.token_owner,376			},377			PropertyPermission {378				code: TokenPermissionField::CollectionAdmin,379				value: pp.collection_admin,380			},381		]382	}383384	/// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].385	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {386		let mut token_permission = up_data_structs::PropertyPermission::default();387388		for PropertyPermission { code, value } in permission {389			match code {390				TokenPermissionField::Mutable => token_permission.mutable = value,391				TokenPermissionField::TokenOwner => token_permission.token_owner = value,392				TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,393			}394		}395		token_permission396	}397}398399/// Ethereum representation of Token Property Permissions.400#[derive(Debug, Default, AbiCoder)]401pub struct TokenPropertyPermission {402	/// Token property key.403	key: evm_coder::types::string,404	/// Token property permissions.405	permissions: Vec<PropertyPermission>,406}407408impl409	From<(410		up_data_structs::PropertyKey,411		up_data_structs::PropertyPermission,412	)> for TokenPropertyPermission413{414	fn from(415		value: (416			up_data_structs::PropertyKey,417			up_data_structs::PropertyPermission,418		),419	) -> Self {420		let (key, permission) = value;421		let key = evm_coder::types::string::from_utf8(key.into_inner())422			.expect("Stored key must be valid");423		let permissions = PropertyPermission::into_vec(permission);424		Self { key, permissions }425	}426}427428impl TokenPropertyPermission {429	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].430	pub fn into_property_key_permissions(431		permissions: Vec<TokenPropertyPermission>,432	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {433		let mut perms = Vec::new();434435		for TokenPropertyPermission { key, permissions } in permissions {436			if permissions.len() > <TokenPermissionField as evm_coder::abi::AbiType>::FIELDS_COUNT {437				return Err(alloc::format!(438					"Actual number of fields {} for {}, which exceeds the maximum value of {}",439					permissions.len(),440					stringify!(EthTokenPermissions),441					<TokenPermissionField as evm_coder::abi::AbiType>::FIELDS_COUNT442				)443				.as_str()444				.into());445			}446447			let token_permission = PropertyPermission::from_vec(permissions);448449			perms.push(up_data_structs::PropertyKeyPermission {450				key: key.into_bytes().try_into().map_err(|_| "too long key")?,451				permission: token_permission,452			});453		}454		Ok(perms)455	}456}457458/// Nested collections.459#[derive(Debug, Default, AbiCoder)]460pub struct CollectionNesting {461	token_owner: bool,462	ids: Vec<uint256>,463}464465impl CollectionNesting {466	/// Create [`CollectionNesting`].467	pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {468		Self { token_owner, ids }469	}470}471472/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.473#[derive(Debug, Default, AbiCoder)]474pub struct CollectionNestingPermission {475	field: CollectionPermissionField,476	value: bool,477}478479impl CollectionNestingPermission {480	/// Create [`CollectionNestingPermission`].481	pub fn new(field: CollectionPermissionField, value: bool) -> Self {482		Self { field, value }483	}484}