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

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::{AbiCoder, types::Address};22pub use pallet_evm::{Config, account::CrossAccountId};23use sp_core::{H160, U256};24use up_data_structs::CollectionId;2526// 0x17c4e6453Cc49AAAaEACA894e6D9683e00000001 - collection 127// TODO: Unhardcode prefix28const ETH_COLLECTION_PREFIX: [u8; 16] = [29	0x17, 0xc4, 0xe6, 0x45, 0x3c, 0xc4, 0x9a, 0xaa, 0xae, 0xac, 0xa8, 0x94, 0xe6, 0xd9, 0x68, 0x3e,30];3132/// Maps the ethereum address of the collection in substrate.33pub fn map_eth_to_id(eth: &Address) -> Option<CollectionId> {34	if eth[0..16] != ETH_COLLECTION_PREFIX {35		return None;36	}37	let mut id_bytes = [0; 4];38	id_bytes.copy_from_slice(&eth[16..20]);39	Some(CollectionId(u32::from_be_bytes(id_bytes)))40}4142/// Maps the substrate collection id in ethereum.43pub fn collection_id_to_address(id: CollectionId) -> Address {44	let mut out = [0; 20];45	out[0..16].copy_from_slice(&ETH_COLLECTION_PREFIX);46	out[16..20].copy_from_slice(&u32::to_be_bytes(id.0));47	H160(out)48}4950/// Check if the ethereum address is a collection.51pub fn is_collection(address: &Address) -> bool {52	address[0..16] == ETH_COLLECTION_PREFIX53}5455/// Convert `U256` to `CrossAccountId`.56pub fn convert_uint256_to_cross_account<T: Config>(from: U256) -> T::CrossAccountId57where58	T::AccountId: From<[u8; 32]>,59{60	let mut new_admin_arr = [0_u8; 32];61	from.to_big_endian(&mut new_admin_arr);62	let account_id = T::AccountId::from(new_admin_arr);63	T::CrossAccountId::from_sub(account_id)64}6566/// Cross account struct67#[derive(Debug, Default, AbiCoder)]68pub struct CrossAddress {69	pub(crate) eth: Address,70	pub(crate) sub: U256,71}7273impl CrossAddress {74	/// Converts `CrossAccountId` to [`CrossAddress`] to be correctly usable with Ethereum.75	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self76	where77		T: pallet_evm::Config,78		T::AccountId: AsRef<[u8; 32]>,79	{80		if cross_account_id.is_canonical_substrate() {81			Self::from_sub::<T>(cross_account_id.as_sub())82		} else {83			Self::from_eth(*cross_account_id.as_eth())84		}85	}86	/// Creates [`CrossAddress`] from Substrate account.87	pub fn from_sub<T>(account_id: &T::AccountId) -> Self88	where89		T: pallet_evm::Config,90		T::AccountId: AsRef<[u8; 32]>,91	{92		Self {93			eth: Default::default(),94			sub: U256::from_big_endian(account_id.as_ref()),95		}96	}97	/// Creates [`CrossAddress`] from Ethereum account.98	pub fn from_eth(address: Address) -> Self {99		Self {100			eth: address,101			sub: Default::default(),102		}103	}104	/// Converts [`CrossAddress`] to `CrossAccountId`.105	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>106	where107		T: pallet_evm::Config,108		T::AccountId: From<[u8; 32]>,109	{110		if self.eth == Default::default() && self.sub == Default::default() {111			Err("All fields of cross account is zeroed".into())112		} else if self.eth == Default::default() {113			Ok(convert_uint256_to_cross_account::<T>(self.sub))114		} else if self.sub == Default::default() {115			Ok(T::CrossAccountId::from_eth(self.eth))116		} else {117			Err("All fields of cross account is non zeroed".into())118		}119	}120}121122/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).123#[derive(Debug, Default, AbiCoder)]124pub struct Property {125	key: evm_coder::types::String,126	value: evm_coder::types::Bytes,127}128129impl TryFrom<up_data_structs::Property> for Property {130	type Error = evm_coder::execution::Error;131132	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {133		let key = evm_coder::types::String::from_utf8(from.key.into())134			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;135		let value = evm_coder::types::Bytes(from.value.to_vec());136		Ok(Property { key, value })137	}138}139140impl TryInto<up_data_structs::Property> for Property {141	type Error = evm_coder::execution::Error;142143	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {144		let key = <Vec<u8>>::from(self.key)145			.try_into()146			.map_err(|_| "key too large")?;147148		let value = self.value.0.try_into().map_err(|_| "value too large")?;149150		Ok(up_data_structs::Property { key, value })151	}152}153154/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.155#[derive(Debug, Default, Clone, Copy, AbiCoder)]156#[repr(u8)]157pub enum CollectionLimitField {158	/// How many tokens can a user have on one account.159	#[default]160	AccountTokenOwnership,161162	/// How many bytes of data are available for sponsorship.163	SponsoredDataSize,164165	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]166	SponsoredDataRateLimit,167168	/// How many tokens can be mined into this collection.169	TokenLimit,170171	/// Timeouts for transfer sponsoring.172	SponsorTransferTimeout,173174	/// Timeout for sponsoring an approval in passed blocks.175	SponsorApproveTimeout,176177	/// Whether the collection owner of the collection can send tokens (which belong to other users).178	OwnerCanTransfer,179180	/// Can the collection owner burn other people's tokens.181	OwnerCanDestroy,182183	/// Is it possible to send tokens from this collection between users.184	TransferEnabled,185}186187/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.188#[derive(Debug, Default, AbiCoder)]189pub struct CollectionLimit {190	field: CollectionLimitField,191	value: Option<U256>,192}193194impl CollectionLimit {195	/// Create [`CollectionLimit`] from field and value.196	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {197		Self {198			field,199			value: match value {200				Some(value) => Some(value.into()),201				None => None,202			},203		}204	}205	/// Whether the field contains a value.206	pub fn has_value(&self) -> bool {207		self.value.is_some()208	}209}210211impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {212	type Error = evm_coder::execution::Error;213214	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {215		let value = self216			.value217			.ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;218		let value = Some(value.try_into().map_err(|error| {219			Self::Error::Revert(format!(220				"can't convert value to u32 \"{}\" because: \"{error}\"",221				value222			))223		})?);224225		let convert_value_to_bool = || match value {226			Some(value) => match value {227				0 => Ok(Some(false)),228				1 => Ok(Some(true)),229				_ => {230					return Err(Self::Error::Revert(format!(231						"can't convert value to boolean \"{value}\""232					)))233				}234			},235			None => Ok(None),236		};237238		let mut limits = up_data_structs::CollectionLimits::default();239		match self.field {240			CollectionLimitField::AccountTokenOwnership => {241				limits.account_token_ownership_limit = value;242			}243			CollectionLimitField::SponsoredDataSize => {244				limits.sponsored_data_size = value;245			}246			CollectionLimitField::SponsoredDataRateLimit => {247				limits.sponsored_data_rate_limit = match value {248					Some(value) => Some(up_data_structs::SponsoringRateLimit::Blocks(value)),249					None => None,250				};251			}252			CollectionLimitField::TokenLimit => {253				limits.token_limit = value;254			}255			CollectionLimitField::SponsorTransferTimeout => {256				limits.sponsor_transfer_timeout = value;257			}258			CollectionLimitField::SponsorApproveTimeout => {259				limits.sponsor_approve_timeout = value;260			}261			CollectionLimitField::OwnerCanTransfer => {262				limits.owner_can_transfer = convert_value_to_bool()?;263			}264			CollectionLimitField::OwnerCanDestroy => {265				limits.owner_can_destroy = convert_value_to_bool()?;266			}267			CollectionLimitField::TransferEnabled => {268				limits.transfers_enabled = convert_value_to_bool()?;269			}270		};271		Ok(limits)272	}273}274275/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.276#[derive(Default, Debug, Clone, Copy, AbiCoder)]277#[repr(u8)]278pub enum CollectionPermissionField {279	/// Owner of token can nest tokens under it.280	#[default]281	TokenOwner,282283	/// Admin of token collection can nest tokens under token.284	CollectionAdmin,285}286287/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.288#[derive(AbiCoder, Copy, Clone, Default, Debug)]289#[repr(u8)]290pub enum TokenPermissionField {291	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]292	#[default]293	Mutable,294295	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]296	TokenOwner,297298	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]299	CollectionAdmin,300}301302/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.303#[derive(Debug, Default, AbiCoder)]304pub struct PropertyPermission {305	/// TokenPermission field.306	code: TokenPermissionField,307	/// TokenPermission value.308	value: bool,309}310311impl PropertyPermission {312	/// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].313	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {314		vec![315			PropertyPermission {316				code: TokenPermissionField::Mutable,317				value: pp.mutable,318			},319			PropertyPermission {320				code: TokenPermissionField::TokenOwner,321				value: pp.token_owner,322			},323			PropertyPermission {324				code: TokenPermissionField::CollectionAdmin,325				value: pp.collection_admin,326			},327		]328	}329330	/// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].331	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {332		let mut token_permission = up_data_structs::PropertyPermission::default();333334		for PropertyPermission { code, value } in permission {335			match code {336				TokenPermissionField::Mutable => token_permission.mutable = value,337				TokenPermissionField::TokenOwner => token_permission.token_owner = value,338				TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,339			}340		}341		token_permission342	}343}344345/// Ethereum representation of Token Property Permissions.346#[derive(Debug, Default, AbiCoder)]347pub struct TokenPropertyPermission {348	/// Token property key.349	key: evm_coder::types::String,350	/// Token property permissions.351	permissions: Vec<PropertyPermission>,352}353354impl355	From<(356		up_data_structs::PropertyKey,357		up_data_structs::PropertyPermission,358	)> for TokenPropertyPermission359{360	fn from(361		value: (362			up_data_structs::PropertyKey,363			up_data_structs::PropertyPermission,364		),365	) -> Self {366		let (key, permission) = value;367		let key = evm_coder::types::String::from_utf8(key.into_inner())368			.expect("Stored key must be valid");369		let permissions = PropertyPermission::into_vec(permission);370		Self { key, permissions }371	}372}373374impl TokenPropertyPermission {375	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].376	pub fn into_property_key_permissions(377		permissions: Vec<TokenPropertyPermission>,378	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {379		let mut perms = Vec::new();380381		for TokenPropertyPermission { key, permissions } in permissions {382			let token_permission = PropertyPermission::from_vec(permissions);383384			perms.push(up_data_structs::PropertyKeyPermission {385				key: key.into_bytes().try_into().map_err(|_| "too long key")?,386				permission: token_permission,387			});388		}389		Ok(perms)390	}391}392393/// Nested collections.394#[derive(Debug, Default, AbiCoder)]395pub struct CollectionNesting {396	token_owner: bool,397	ids: Vec<U256>,398}399400impl CollectionNesting {401	/// Create [`CollectionNesting`].402	pub fn new(token_owner: bool, ids: Vec<U256>) -> Self {403		Self { token_owner, ids }404	}405}406407/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.408#[derive(Debug, Default, AbiCoder)]409pub struct CollectionNestingPermission {410	field: CollectionPermissionField,411	value: bool,412}413414impl CollectionNestingPermission {415	/// Create [`CollectionNestingPermission`].416	pub fn new(field: CollectionPermissionField, value: bool) -> Self {417		Self { field, value }418	}419}420421/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).422#[derive(AbiCoder, Copy, Clone, Default, Debug)]423#[repr(u8)]424pub enum AccessMode {425	/// Access grant for owner and admins. Used as default.426	#[default]427	Normal,428	/// Like a [`Normal`](AccessMode::Normal) but also users in allow list.429	AllowList,430}431432impl From<up_data_structs::AccessMode> for AccessMode {433	fn from(value: up_data_structs::AccessMode) -> Self {434		match value {435			up_data_structs::AccessMode::Normal => AccessMode::Normal,436			up_data_structs::AccessMode::AllowList => AccessMode::AllowList,437		}438	}439}440441impl Into<up_data_structs::AccessMode> for AccessMode {442	fn into(self) -> up_data_structs::AccessMode {443		match self {444			AccessMode::Normal => up_data_structs::AccessMode::Normal,445			AccessMode::AllowList => up_data_structs::AccessMode::AllowList,446		}447	}448}