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

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<bool> for OptionUint {101	fn from(value: bool) -> Self {102		Self {103			status: true,104			value: if value {105				uint256::from(1)106			} else {107				Default::default()108			},109		}110	}111}112113impl From<Option<bool>> for OptionUint {114	fn from(value: Option<bool>) -> Self {115		match value {116			Some(value) => Self::from(value),117			None => Self {118				status: false,119				value: Default::default(),120			},121		}122	}123}124125/// Cross account struct126#[derive(Debug, Default, AbiCoder)]127pub struct CrossAddress {128	pub(crate) eth: address,129	pub(crate) sub: uint256,130}131132impl CrossAddress {133	/// Converts `CrossAccountId` to [`CrossAddress`]134	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self135	where136		T: pallet_evm::Config,137		T::AccountId: AsRef<[u8; 32]>,138	{139		if cross_account_id.is_canonical_substrate() {140			Self::from_sub::<T>(cross_account_id.as_sub())141		} else {142			Self {143				eth: *cross_account_id.as_eth(),144				sub: Default::default(),145			}146		}147	}148	/// Creates [`CrossAddress`] from substrate account149	pub fn from_sub<T>(account_id: &T::AccountId) -> Self150	where151		T: pallet_evm::Config,152		T::AccountId: AsRef<[u8; 32]>,153	{154		Self {155			eth: Default::default(),156			sub: uint256::from_big_endian(account_id.as_ref()),157		}158	}159	/// Converts [`CrossAddress`] to `CrossAccountId`160	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>161	where162		T: pallet_evm::Config,163		T::AccountId: From<[u8; 32]>,164	{165		if self.eth == Default::default() && self.sub == Default::default() {166			Err("All fields of cross account is zeroed".into())167		} else if self.eth == Default::default() {168			Ok(convert_uint256_to_cross_account::<T>(self.sub))169		} else if self.sub == Default::default() {170			Ok(T::CrossAccountId::from_eth(self.eth))171		} else {172			Err("All fields of cross account is non zeroed".into())173		}174	}175}176177/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).178#[derive(Debug, Default, AbiCoder)]179pub struct Property {180	key: evm_coder::types::string,181	value: evm_coder::types::bytes,182}183184impl TryFrom<up_data_structs::Property> for Property {185	type Error = evm_coder::execution::Error;186187	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {188		let key = evm_coder::types::string::from_utf8(from.key.into())189			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;190		let value = evm_coder::types::bytes(from.value.to_vec());191		Ok(Property { key, value })192	}193}194195impl TryInto<up_data_structs::Property> for Property {196	type Error = evm_coder::execution::Error;197198	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {199		let key = <Vec<u8>>::from(self.key)200			.try_into()201			.map_err(|_| "key too large")?;202203		let value = self.value.0.try_into().map_err(|_| "value too large")?;204205		Ok(up_data_structs::Property { key, value })206	}207}208209/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.210#[derive(Debug, Default, Clone, Copy, AbiCoder)]211#[repr(u8)]212pub enum CollectionLimitField {213	/// How many tokens can a user have on one account.214	#[default]215	AccountTokenOwnership,216217	/// How many bytes of data are available for sponsorship.218	SponsoredDataSize,219220	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]221	SponsoredDataRateLimit,222223	/// How many tokens can be mined into this collection.224	TokenLimit,225226	/// Timeouts for transfer sponsoring.227	SponsorTransferTimeout,228229	/// Timeout for sponsoring an approval in passed blocks.230	SponsorApproveTimeout,231232	/// Whether the collection owner of the collection can send tokens (which belong to other users).233	OwnerCanTransfer,234235	/// Can the collection owner burn other people's tokens.236	OwnerCanDestroy,237238	/// Is it possible to send tokens from this collection between users.239	TransferEnabled,240}241242/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.243#[derive(Debug, Default, AbiCoder)]244pub struct CollectionLimit {245	field: CollectionLimitField,246	value: OptionUint,247}248249impl CollectionLimit {250	/// Create [`CollectionLimit`] from field and value.251	pub fn new<T>(field: CollectionLimitField, value: T) -> Self252	where253		OptionUint: From<T>,254	{255		Self {256			field,257			value: value.into(),258		}259	}260	/// Whether the field contains a value.261	pub fn has_value(&self) -> bool {262		self.value.status263	}264}265266impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {267	type Error = evm_coder::execution::Error;268269	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {270		let value = self.value.value.try_into().map_err(|error| {271			Self::Error::Revert(format!(272				"can't convert value to u32 \"{}\" because: \"{error}\"",273				self.value.value274			))275		})?;276277		let convert_value_to_bool = || match value {278			0 => Ok(false),279			1 => Ok(true),280			_ => {281				return Err(Self::Error::Revert(format!(282					"can't convert value to boolean \"{value}\""283				)))284			}285		};286287		let mut limits = up_data_structs::CollectionLimits::default();288		match self.field {289			CollectionLimitField::AccountTokenOwnership => {290				limits.account_token_ownership_limit = Some(value);291			}292			CollectionLimitField::SponsoredDataSize => {293				limits.sponsored_data_size = Some(value);294			}295			CollectionLimitField::SponsoredDataRateLimit => {296				limits.sponsored_data_rate_limit =297					Some(up_data_structs::SponsoringRateLimit::Blocks(value));298			}299			CollectionLimitField::TokenLimit => {300				limits.token_limit = Some(value);301			}302			CollectionLimitField::SponsorTransferTimeout => {303				limits.sponsor_transfer_timeout = Some(value);304			}305			CollectionLimitField::SponsorApproveTimeout => {306				limits.sponsor_approve_timeout = Some(value);307			}308			CollectionLimitField::OwnerCanTransfer => {309				limits.owner_can_transfer = Some(convert_value_to_bool()?);310			}311			CollectionLimitField::OwnerCanDestroy => {312				limits.owner_can_destroy = Some(convert_value_to_bool()?);313			}314			CollectionLimitField::TransferEnabled => {315				limits.transfers_enabled = Some(convert_value_to_bool()?);316			}317		};318		Ok(limits)319	}320}321322/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.323#[derive(Default, Debug, Clone, Copy, AbiCoder)]324#[repr(u8)]325pub enum CollectionPermissionField {326	/// Owner of token can nest tokens under it.327	#[default]328	TokenOwner,329330	/// Admin of token collection can nest tokens under token.331	CollectionAdmin,332}333334/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.335#[derive(AbiCoder, Copy, Clone, Default, Debug)]336#[repr(u8)]337pub enum TokenPermissionField {338	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]339	#[default]340	Mutable,341342	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]343	TokenOwner,344345	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]346	CollectionAdmin,347}348349/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.350#[derive(Debug, Default, AbiCoder)]351pub struct PropertyPermission {352	/// TokenPermission field.353	code: TokenPermissionField,354	/// TokenPermission value.355	value: bool,356}357358impl PropertyPermission {359	/// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].360	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {361		vec![362			PropertyPermission {363				code: TokenPermissionField::Mutable,364				value: pp.mutable,365			},366			PropertyPermission {367				code: TokenPermissionField::TokenOwner,368				value: pp.token_owner,369			},370			PropertyPermission {371				code: TokenPermissionField::CollectionAdmin,372				value: pp.collection_admin,373			},374		]375	}376377	/// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].378	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {379		let mut token_permission = up_data_structs::PropertyPermission::default();380381		for PropertyPermission { code, value } in permission {382			match code {383				TokenPermissionField::Mutable => token_permission.mutable = value,384				TokenPermissionField::TokenOwner => token_permission.token_owner = value,385				TokenPermissionField::CollectionAdmin => token_permission.collection_admin = value,386			}387		}388		token_permission389	}390}391392/// Ethereum representation of Token Property Permissions.393#[derive(Debug, Default, AbiCoder)]394pub struct TokenPropertyPermission {395	/// Token property key.396	key: evm_coder::types::string,397	/// Token property permissions.398	permissions: Vec<PropertyPermission>,399}400401impl402	From<(403		up_data_structs::PropertyKey,404		up_data_structs::PropertyPermission,405	)> for TokenPropertyPermission406{407	fn from(408		value: (409			up_data_structs::PropertyKey,410			up_data_structs::PropertyPermission,411		),412	) -> Self {413		let (key, permission) = value;414		let key = evm_coder::types::string::from_utf8(key.into_inner())415			.expect("Stored key must be valid");416		let permissions = PropertyPermission::into_vec(permission);417		Self { key, permissions }418	}419}420421impl TokenPropertyPermission {422	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].423	pub fn into_property_key_permissions(424		permissions: Vec<TokenPropertyPermission>,425	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {426		let mut perms = Vec::new();427428		for TokenPropertyPermission { key, permissions } in permissions {429			let token_permission = PropertyPermission::from_vec(permissions);430431			perms.push(up_data_structs::PropertyKeyPermission {432				key: key.into_bytes().try_into().map_err(|_| "too long key")?,433				permission: token_permission,434			});435		}436		Ok(perms)437	}438}439440/// Nested collections.441#[derive(Debug, Default, AbiCoder)]442pub struct CollectionNesting {443	token_owner: bool,444	ids: Vec<uint256>,445}446447impl CollectionNesting {448	/// Create [`CollectionNesting`].449	pub fn new(token_owner: bool, ids: Vec<uint256>) -> Self {450		Self { token_owner, ids }451	}452}453454/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.455#[derive(Debug, Default, AbiCoder)]456pub struct CollectionNestingPermission {457	field: CollectionPermissionField,458	value: bool,459}460461impl CollectionNestingPermission {462	/// Create [`CollectionNestingPermission`].463	pub fn new(field: CollectionPermissionField, value: bool) -> Self {464		Self { field, value }465	}466}