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

35use crate::{35use crate::{
36	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,36	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
37	eth::{37	eth::{
38		Property as PropertyStruct, EthCrossAccount, CollectionPermissions as EvmPermissions,38		CollectionPermissions as EvmPermissions, CollectionLimitField as EvmCollectionLimits, self,
39		CollectionLimitField as EvmCollectionLimits, self,
40	},39	},
41	weights::WeightInfo,40	weights::WeightInfo,
122	fn set_collection_properties(121	fn set_collection_properties(
123		&mut self,122		&mut self,
124		caller: caller,123		caller: caller,
125		properties: Vec<PropertyStruct>,124		properties: Vec<eth::Property>,
126	) -> Result<void> {125	) -> Result<void> {
127		let caller = T::CrossAccountId::from_eth(caller);126		let caller = T::CrossAccountId::from_eth(caller);
128127
129		let properties = properties128		let properties = properties
130			.into_iter()129			.into_iter()
131			.map(|PropertyStruct { key, value }| {130			.map(|eth::Property { key, value }| {
132				let key = <Vec<u8>>::from(key)131				let key = <Vec<u8>>::from(key)
133					.try_into()132					.try_into()
134					.map_err(|_| "key too large")?;133					.map_err(|_| "key too large")?;
196	///195	///
197	/// @param keys Properties keys. Empty keys for all propertyes.196	/// @param keys Properties keys. Empty keys for all propertyes.
198	/// @return Vector of properties key/value pairs.197	/// @return Vector of properties key/value pairs.
199	fn collection_properties(&self, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {198	fn collection_properties(&self, keys: Vec<string>) -> Result<Vec<eth::Property>> {
200		let keys = keys199		let keys = keys
201			.into_iter()200			.into_iter()
202			.map(|key| {201			.map(|key| {
218				let key =217				let key =
219					string::from_utf8(p.key.into()).map_err(|e| Error::Revert(format!("{}", e)))?;218					string::from_utf8(p.key.into()).map_err(|e| Error::Revert(format!("{}", e)))?;
220				let value = bytes(p.value.to_vec());219				let value = bytes(p.value.to_vec());
221				Ok(PropertyStruct { key, value })220				Ok(eth::Property { key, value })
222			})221			})
223			.collect::<Result<Vec<_>>>()?;222			.collect::<Result<Vec<_>>>()?;
224		Ok(properties)223		Ok(properties)
248	fn set_collection_sponsor_cross(247	fn set_collection_sponsor_cross(
249		&mut self,248		&mut self,
250		caller: caller,249		caller: caller,
251		sponsor: EthCrossAccount,250		sponsor: eth::CrossAccount,
252	) -> Result<void> {251	) -> Result<void> {
253		self.consume_store_reads_and_writes(1, 1)?;252		self.consume_store_reads_and_writes(1, 1)?;
254253
288	/// Get current sponsor.287	/// Get current sponsor.
289	///288	///
290	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.289	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
291	fn collection_sponsor(&self) -> Result<EthCrossAccount> {290	fn collection_sponsor(&self) -> Result<eth::CrossAccount> {
292		let sponsor = match self.collection.sponsorship.sponsor() {291		let sponsor = match self.collection.sponsorship.sponsor() {
293			Some(sponsor) => sponsor,292			Some(sponsor) => sponsor,
294			None => return Ok(Default::default()),293			None => return Ok(Default::default()),
295		};294		};
296295
297		Ok(EthCrossAccount::from_sub::<T>(&sponsor))296		Ok(eth::CrossAccount::from_sub::<T>(&sponsor))
298	}297	}
299298
300	/// Get current collection limits.299	/// Get current collection limits.
377	fn add_collection_admin_cross(376	fn add_collection_admin_cross(
378		&mut self,377		&mut self,
379		caller: caller,378		caller: caller,
380		new_admin: EthCrossAccount,379		new_admin: eth::CrossAccount,
381	) -> Result<void> {380	) -> Result<void> {
382		self.consume_store_reads_and_writes(2, 2)?;381		self.consume_store_reads_and_writes(2, 2)?;
383382
392	fn remove_collection_admin_cross(391	fn remove_collection_admin_cross(
393		&mut self,392		&mut self,
394		caller: caller,393		caller: caller,
395		admin: EthCrossAccount,394		admin: eth::CrossAccount,
396	) -> Result<void> {395	) -> Result<void> {
397		self.consume_store_reads_and_writes(2, 2)?;396		self.consume_store_reads_and_writes(2, 2)?;
398397
534	/// Checks that user allowed to operate with collection.533	/// Checks that user allowed to operate with collection.
535	///534	///
536	/// @param user User address to check.535	/// @param user User address to check.
537	fn allowlisted_cross(&self, user: EthCrossAccount) -> Result<bool> {536	fn allowlisted_cross(&self, user: eth::CrossAccount) -> Result<bool> {
538		let user = user.into_sub_cross_account::<T>()?;537		let user = user.into_sub_cross_account::<T>()?;
539		Ok(Pallet::<T>::allowed(self.id, user))538		Ok(Pallet::<T>::allowed(self.id, user))
540	}539	}
558	fn add_to_collection_allow_list_cross(557	fn add_to_collection_allow_list_cross(
559		&mut self,558		&mut self,
560		caller: caller,559		caller: caller,
561		user: EthCrossAccount,560		user: eth::CrossAccount,
562	) -> Result<void> {561	) -> Result<void> {
563		self.consume_store_writes(1)?;562		self.consume_store_writes(1)?;
564563
587	fn remove_from_collection_allow_list_cross(586	fn remove_from_collection_allow_list_cross(
588		&mut self,587		&mut self,
589		caller: caller,588		caller: caller,
590		user: EthCrossAccount,589		user: eth::CrossAccount,
591	) -> Result<void> {590	) -> Result<void> {
592		self.consume_store_writes(1)?;591		self.consume_store_writes(1)?;
593592
625	///624	///
626	/// @param user User cross account to verify625	/// @param user User cross account to verify
627	/// @return "true" if account is the owner or admin626	/// @return "true" if account is the owner or admin
628	fn is_owner_or_admin_cross(&self, user: EthCrossAccount) -> Result<bool> {627	fn is_owner_or_admin_cross(&self, user: eth::CrossAccount) -> Result<bool> {
629		let user = user.into_sub_cross_account::<T>()?;628		let user = user.into_sub_cross_account::<T>()?;
630		Ok(self.is_owner_or_admin(&user))629		Ok(self.is_owner_or_admin(&user))
631	}630	}
646	///645	///
647	/// @return Tuble with sponsor address and his substrate mirror.646	/// @return Tuble with sponsor address and his substrate mirror.
648	/// If address is canonical then substrate mirror is zero and vice versa.647	/// If address is canonical then substrate mirror is zero and vice versa.
649	fn collection_owner(&self) -> Result<EthCrossAccount> {648	fn collection_owner(&self) -> Result<eth::CrossAccount> {
650		Ok(EthCrossAccount::from_sub_cross_account::<T>(649		Ok(eth::CrossAccount::from_sub_cross_account::<T>(
651			&T::CrossAccountId::from_sub(self.owner.clone()),650			&T::CrossAccountId::from_sub(self.owner.clone()),
652		))651		))
653	}652	}
670	///669	///
671	/// @return Vector of tuples with admins address and his substrate mirror.670	/// @return Vector of tuples with admins address and his substrate mirror.
672	/// If address is canonical then substrate mirror is zero and vice versa.671	/// If address is canonical then substrate mirror is zero and vice versa.
673	fn collection_admins(&self) -> Result<Vec<EthCrossAccount>> {672	fn collection_admins(&self) -> Result<Vec<eth::CrossAccount>> {
674		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))673		let result = crate::IsAdmin::<T>::iter_prefix((self.id,))
675			.map(|(admin, _)| EthCrossAccount::from_sub_cross_account::<T>(&admin))674			.map(|(admin, _)| eth::CrossAccount::from_sub_cross_account::<T>(&admin))
676			.collect();675			.collect();
677		Ok(result)676		Ok(result)
678	}677	}
684	fn change_collection_owner_cross(683	fn change_collection_owner_cross(
685		&mut self,684		&mut self,
686		caller: caller,685		caller: caller,
687		new_owner: EthCrossAccount,686		new_owner: eth::CrossAccount,
688	) -> Result<void> {687	) -> Result<void> {
689		self.consume_store_writes(1)?;688		self.consume_store_writes(1)?;
690689
695	}694	}
696}695}
697
698/// ### Note
699/// Do not forget to add: `self.consume_store_reads(1)?;`
700fn check_is_owner_or_admin<T: Config>(
701	caller: caller,
702	collection: &CollectionHandle<T>,
703) -> Result<T::CrossAccountId> {
704	let caller = T::CrossAccountId::from_eth(caller);
705	collection
706		.check_is_owner_or_admin(&caller)
707		.map_err(dispatch_to_evm::<T>)?;
708	Ok(caller)
709}
710
711/// ### Note
712/// Do not forget to add: `self.consume_store_writes(1)?;`
713fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {
714	collection
715		.check_is_internal()
716		.map_err(dispatch_to_evm::<T>)?;
717	collection.save().map_err(dispatch_to_evm::<T>)?;
718	Ok(())
719}
720696
721/// Contains static property keys and values.697/// Contains static property keys and values.
722pub mod static_property {698pub mod static_property {

6868
69/// Cross account struct69/// Cross account struct
70#[derive(Debug, Default, AbiCoder)]70#[derive(Debug, Default, AbiCoder)]
71pub struct EthCrossAccount {71pub struct CrossAccount {
72	pub(crate) eth: address,72	pub(crate) eth: address,
73	pub(crate) sub: uint256,73	pub(crate) sub: uint256,
74}74}
7575
76impl EthCrossAccount {76impl CrossAccount {
77	/// Converts `CrossAccountId` to `EthCrossAccountId`77	/// Converts `CrossAccountId` to [`CrossAccount`]
78	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self78	pub fn from_sub_cross_account<T>(cross_account_id: &T::CrossAccountId) -> Self
79	where79	where
80		T: pallet_evm::Config,80		T: pallet_evm::Config,
89			}89			}
90		}90		}
91	}91	}
92	/// Creates `EthCrossAccount` from substrate account92	/// Creates [`CrossAccount`] from substrate account
93	pub fn from_sub<T>(account_id: &T::AccountId) -> Self93	pub fn from_sub<T>(account_id: &T::AccountId) -> Self
94	where94	where
95		T: pallet_evm::Config,95		T: pallet_evm::Config,
100			sub: uint256::from_big_endian(account_id.as_ref()),100			sub: uint256::from_big_endian(account_id.as_ref()),
101		}101		}
102	}102	}
103	/// Converts `EthCrossAccount` to `CrossAccountId`103	/// Converts [`CrossAccount`] to `CrossAccountId`
104	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>104	pub fn into_sub_cross_account<T>(&self) -> evm_coder::execution::Result<T::CrossAccountId>
105	where105	where
106		T: pallet_evm::Config,106		T: pallet_evm::Config,
127	pub value: evm_coder::types::bytes,127	pub value: evm_coder::types::bytes,
128}128}
129129
130/// [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.130/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.
131#[derive(Debug, Default, Clone, Copy, AbiCoder)]131#[derive(Debug, Default, Clone, Copy, AbiCoder)]
132#[repr(u8)]132#[repr(u8)]
133pub enum CollectionLimitField {133pub enum CollectionLimitField {
160	TransferEnabled,160	TransferEnabled,
161}161}
162162
163/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
163#[derive(Debug, Default, AbiCoder)]164#[derive(Debug, Default, AbiCoder)]
164pub struct CollectionLimit {165pub struct CollectionLimit {
165	field: CollectionLimitField,166	field: CollectionLimitField,
168}169}
169170
170impl CollectionLimit {171impl CollectionLimit {
172	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and int value.
171	pub fn from_int(field: CollectionLimitField, value: u32) -> Self {173	pub fn from_int(field: CollectionLimitField, value: u32) -> Self {
172		Self {174		Self {
173			field,175			field,
176		}178		}
177	}179	}
178180
181	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and optional int value.
179	pub fn from_opt_int(field: CollectionLimitField, value: Option<u32>) -> Self {182	pub fn from_opt_int(field: CollectionLimitField, value: Option<u32>) -> Self {
180		value183		value
181			.map(|v| Self {184			.map(|v| Self {
190			})193			})
191	}194	}
192195
196	/// Make [`CollectionLimit`] from [`CollectionLimitField`] and bool value.
193	pub fn from_opt_bool(field: CollectionLimitField, value: Option<bool>) -> Self {197	pub fn from_opt_bool(field: CollectionLimitField, value: Option<bool>) -> Self {
194		value198		value
195			.map(|v| Self {199			.map(|v| Self {
306}310}
307311
308impl PropertyPermission {312impl PropertyPermission {
313	/// Make vector of [`PropertyPermission`] from [`up_data_structs::PropertyPermission`].
309	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {314	pub fn into_vec(pp: up_data_structs::PropertyPermission) -> Vec<Self> {
310		vec![315		vec![
311			PropertyPermission {316			PropertyPermission {
323		]328		]
324	}329	}
325330
331	/// Make [`up_data_structs::PropertyPermission`] from vector of [`PropertyPermission`].
326	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {332	pub fn from_vec(permission: Vec<Self>) -> up_data_structs::PropertyPermission {
327		let mut token_permission = up_data_structs::PropertyPermission::default();333		let mut token_permission = up_data_structs::PropertyPermission::default();
328334
367}373}
368374
369impl TokenPropertyPermission {375impl TokenPropertyPermission {
376	/// Convert vector of [`TokenPropertyPermission`] into vector of [`up_data_structs::PropertyKeyPermission`].
370	pub fn into_property_key_permissions(377	pub fn into_property_key_permissions(
371		permissions: Vec<TokenPropertyPermission>,378		permissions: Vec<TokenPropertyPermission>,
372	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {379	) -> evm_coder::execution::Result<Vec<up_data_structs::PropertyKeyPermission>> {

25	types::*,25	types::*,
26	ToLog,26	ToLog,
27};27};
28use pallet_common::eth::EthCrossAccount;
29use pallet_evm::{28use pallet_evm::{
30	ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle,29	ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle,
31	account::CrossAccountId,30	account::CrossAccountId,
175	///174	///
176	/// @param contractAddress The contract for which a sponsor is requested.175	/// @param contractAddress The contract for which a sponsor is requested.
177	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.176	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
178	fn sponsor(&self, contract_address: address) -> Result<EthCrossAccount> {177	fn sponsor(&self, contract_address: address) -> Result<pallet_common::eth::CrossAccount> {
179		Ok(EthCrossAccount::from_sub_cross_account::<T>(178		Ok(
179			pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(
180			&Pallet::<T>::get_sponsor(contract_address).ok_or("Contract has no sponsor")?,180				&Pallet::<T>::get_sponsor(contract_address).ok_or("Contract has no sponsor")?,
181		))181			),
182		)
182	}183	}
183184

binary blob — no preview

96	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.96	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
97	/// @dev EVM selector for this function is: 0x766c4f37,97	/// @dev EVM selector for this function is: 0x766c4f37,
98	///  or in textual repr: sponsor(address)98	///  or in textual repr: sponsor(address)
99	function sponsor(address contractAddress) public view returns (EthCrossAccount memory) {99	function sponsor(address contractAddress) public view returns (CrossAccount memory) {
100		require(false, stub_error);100		require(false, stub_error);
101		contractAddress;101		contractAddress;
102		dummy;102		dummy;
103		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);103		return CrossAccount(0x0000000000000000000000000000000000000000, 0);
104	}104	}
105105
106	/// Check tat contract has confirmed sponsor.106	/// Check tat contract has confirmed sponsor.
266}266}
267267
268/// @dev Cross account struct268/// @dev Cross account struct
269struct EthCrossAccount {269struct CrossAccount {
270	address eth;270	address eth;
271	uint256 sub;271	uint256 sub;
272}272}

27use pallet_common::{27use pallet_common::{
28	CollectionHandle,28	CollectionHandle,
29	erc::{CommonEvmHandler, PrecompileResult, CollectionCall},29	erc::{CommonEvmHandler, PrecompileResult, CollectionCall},
30	eth::EthCrossAccount,
31};30};
32use sp_std::vec::Vec;31use sp_std::vec::Vec;
33use pallet_evm::{account::CrossAccountId, PrecompileHandle};32use pallet_evm::{account::CrossAccountId, PrecompileHandle};
175	}174	}
176175
177	#[weight(<SelfWeightOf<T>>::create_item())]176	#[weight(<SelfWeightOf<T>>::create_item())]
178	fn mint_cross(&mut self, caller: caller, to: EthCrossAccount, amount: uint256) -> Result<bool> {177	fn mint_cross(
178		&mut self,
179		caller: caller,
180		to: pallet_common::eth::CrossAccount,
181		amount: uint256,
182	) -> Result<bool> {
179		let caller = T::CrossAccountId::from_eth(caller);183		let caller = T::CrossAccountId::from_eth(caller);
180		let to = to.into_sub_cross_account::<T>()?;184		let to = to.into_sub_cross_account::<T>()?;
191	fn approve_cross(195	fn approve_cross(
192		&mut self,196		&mut self,
193		caller: caller,197		caller: caller,
194		spender: EthCrossAccount,198		spender: pallet_common::eth::CrossAccount,
195		amount: uint256,199		amount: uint256,
196	) -> Result<bool> {200	) -> Result<bool> {
197		let caller = T::CrossAccountId::from_eth(caller);201		let caller = T::CrossAccountId::from_eth(caller);
232	fn burn_from_cross(236	fn burn_from_cross(
233		&mut self,237		&mut self,
234		caller: caller,238		caller: caller,
235		from: EthCrossAccount,239		from: pallet_common::eth::CrossAccount,
236		amount: uint256,240		amount: uint256,
237	) -> Result<bool> {241	) -> Result<bool> {
238		let caller = T::CrossAccountId::from_eth(caller);242		let caller = T::CrossAccountId::from_eth(caller);
274	fn transfer_cross(278	fn transfer_cross(
275		&mut self,279		&mut self,
276		caller: caller,280		caller: caller,
277		to: EthCrossAccount,281		to: pallet_common::eth::CrossAccount,
278		amount: uint256,282		amount: uint256,
279	) -> Result<bool> {283	) -> Result<bool> {
280		let caller = T::CrossAccountId::from_eth(caller);284		let caller = T::CrossAccountId::from_eth(caller);
292	fn transfer_from_cross(296	fn transfer_from_cross(
293		&mut self,297		&mut self,
294		caller: caller,298		caller: caller,
295		from: EthCrossAccount,299		from: pallet_common::eth::CrossAccount,
296		to: EthCrossAccount,300		to: pallet_common::eth::CrossAccount,
297		amount: uint256,301		amount: uint256,
298	) -> Result<bool> {302	) -> Result<bool> {
299		let caller = T::CrossAccountId::from_eth(caller);303		let caller = T::CrossAccountId::from_eth(caller);

binary blob — no preview

114	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.114	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.
115	/// @dev EVM selector for this function is: 0x84a1d5a8,115	/// @dev EVM selector for this function is: 0x84a1d5a8,
116	///  or in textual repr: setCollectionSponsorCross((address,uint256))116	///  or in textual repr: setCollectionSponsorCross((address,uint256))
117	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {117	function setCollectionSponsorCross(CrossAccount memory sponsor) public {
118		require(false, stub_error);118		require(false, stub_error);
119		sponsor;119		sponsor;
120		dummy = 0;120		dummy = 0;
152	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.152	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
153	/// @dev EVM selector for this function is: 0x6ec0a9f1,153	/// @dev EVM selector for this function is: 0x6ec0a9f1,
154	///  or in textual repr: collectionSponsor()154	///  or in textual repr: collectionSponsor()
155	function collectionSponsor() public view returns (EthCrossAccount memory) {155	function collectionSponsor() public view returns (CrossAccount memory) {
156		require(false, stub_error);156		require(false, stub_error);
157		dummy;157		dummy;
158		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);158		return CrossAccount(0x0000000000000000000000000000000000000000, 0);
159	}159	}
160160
161	/// Get current collection limits.161	/// Get current collection limits.
193	/// @param newAdmin Cross account administrator address.193	/// @param newAdmin Cross account administrator address.
194	/// @dev EVM selector for this function is: 0x859aa7d6,194	/// @dev EVM selector for this function is: 0x859aa7d6,
195	///  or in textual repr: addCollectionAdminCross((address,uint256))195	///  or in textual repr: addCollectionAdminCross((address,uint256))
196	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {196	function addCollectionAdminCross(CrossAccount memory newAdmin) public {
197		require(false, stub_error);197		require(false, stub_error);
198		newAdmin;198		newAdmin;
199		dummy = 0;199		dummy = 0;
203	/// @param admin Cross account administrator address.203	/// @param admin Cross account administrator address.
204	/// @dev EVM selector for this function is: 0x6c0cd173,204	/// @dev EVM selector for this function is: 0x6c0cd173,
205	///  or in textual repr: removeCollectionAdminCross((address,uint256))205	///  or in textual repr: removeCollectionAdminCross((address,uint256))
206	function removeCollectionAdminCross(EthCrossAccount memory admin) public {206	function removeCollectionAdminCross(CrossAccount memory admin) public {
207		require(false, stub_error);207		require(false, stub_error);
208		admin;208		admin;
209		dummy = 0;209		dummy = 0;
289	/// @param user User address to check.289	/// @param user User address to check.
290	/// @dev EVM selector for this function is: 0x91b6df49,290	/// @dev EVM selector for this function is: 0x91b6df49,
291	///  or in textual repr: allowlistedCross((address,uint256))291	///  or in textual repr: allowlistedCross((address,uint256))
292	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {292	function allowlistedCross(CrossAccount memory user) public view returns (bool) {
293		require(false, stub_error);293		require(false, stub_error);
294		user;294		user;
295		dummy;295		dummy;
312	/// @param user User cross account address.312	/// @param user User cross account address.
313	/// @dev EVM selector for this function is: 0xa0184a3a,313	/// @dev EVM selector for this function is: 0xa0184a3a,
314	///  or in textual repr: addToCollectionAllowListCross((address,uint256))314	///  or in textual repr: addToCollectionAllowListCross((address,uint256))
315	function addToCollectionAllowListCross(EthCrossAccount memory user) public {315	function addToCollectionAllowListCross(CrossAccount memory user) public {
316		require(false, stub_error);316		require(false, stub_error);
317		user;317		user;
318		dummy = 0;318		dummy = 0;
334	/// @param user User cross account address.334	/// @param user User cross account address.
335	/// @dev EVM selector for this function is: 0x09ba452a,335	/// @dev EVM selector for this function is: 0x09ba452a,
336	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))336	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))
337	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {337	function removeFromCollectionAllowListCross(CrossAccount memory user) public {
338		require(false, stub_error);338		require(false, stub_error);
339		user;339		user;
340		dummy = 0;340		dummy = 0;
370	/// @return "true" if account is the owner or admin370	/// @return "true" if account is the owner or admin
371	/// @dev EVM selector for this function is: 0x3e75a905,371	/// @dev EVM selector for this function is: 0x3e75a905,
372	///  or in textual repr: isOwnerOrAdminCross((address,uint256))372	///  or in textual repr: isOwnerOrAdminCross((address,uint256))
373	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {373	function isOwnerOrAdminCross(CrossAccount memory user) public view returns (bool) {
374		require(false, stub_error);374		require(false, stub_error);
375		user;375		user;
376		dummy;376		dummy;
394	/// If address is canonical then substrate mirror is zero and vice versa.394	/// If address is canonical then substrate mirror is zero and vice versa.
395	/// @dev EVM selector for this function is: 0xdf727d3b,395	/// @dev EVM selector for this function is: 0xdf727d3b,
396	///  or in textual repr: collectionOwner()396	///  or in textual repr: collectionOwner()
397	function collectionOwner() public view returns (EthCrossAccount memory) {397	function collectionOwner() public view returns (CrossAccount memory) {
398		require(false, stub_error);398		require(false, stub_error);
399		dummy;399		dummy;
400		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);400		return CrossAccount(0x0000000000000000000000000000000000000000, 0);
401	}401	}
402402
403	// /// Changes collection owner to another account403	// /// Changes collection owner to another account
418	/// If address is canonical then substrate mirror is zero and vice versa.418	/// If address is canonical then substrate mirror is zero and vice versa.
419	/// @dev EVM selector for this function is: 0x5813216b,419	/// @dev EVM selector for this function is: 0x5813216b,
420	///  or in textual repr: collectionAdmins()420	///  or in textual repr: collectionAdmins()
421	function collectionAdmins() public view returns (EthCrossAccount[] memory) {421	function collectionAdmins() public view returns (CrossAccount[] memory) {
422		require(false, stub_error);422		require(false, stub_error);
423		dummy;423		dummy;
424		return new EthCrossAccount[](0);424		return new CrossAccount[](0);
425	}425	}
426426
427	/// Changes collection owner to another account427	/// Changes collection owner to another account
430	/// @param newOwner new owner cross account430	/// @param newOwner new owner cross account
431	/// @dev EVM selector for this function is: 0x6496c497,431	/// @dev EVM selector for this function is: 0x6496c497,
432	///  or in textual repr: changeCollectionOwnerCross((address,uint256))432	///  or in textual repr: changeCollectionOwnerCross((address,uint256))
433	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {433	function changeCollectionOwnerCross(CrossAccount memory newOwner) public {
434		require(false, stub_error);434		require(false, stub_error);
435		newOwner;435		newOwner;
436		dummy = 0;436		dummy = 0;
437	}437	}
438}438}
439439
440/// @dev Cross account struct440/// @dev Cross account struct
441struct EthCrossAccount {441struct CrossAccount {
442	address eth;442	address eth;
443	uint256 sub;443	uint256 sub;
444}444}
463	uint256[] field_1;463	uint256[] field_1;
464}464}
465465
466/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.
466struct CollectionLimit {467struct CollectionLimit {
467	CollectionLimitField field;468	CollectionLimitField field;
468	bool status;469	bool status;
469	uint256 value;470	uint256 value;
470}471}
471472
472/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.473/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.
473enum CollectionLimitField {474enum CollectionLimitField {
474	/// @dev How many tokens can a user have on one account.475	/// @dev How many tokens can a user have on one account.
475	AccountTokenOwnership,476	AccountTokenOwnership,
512513
513	/// @dev EVM selector for this function is: 0x269e6158,514	/// @dev EVM selector for this function is: 0x269e6158,
514	///  or in textual repr: mintCross((address,uint256),uint256)515	///  or in textual repr: mintCross((address,uint256),uint256)
515	function mintCross(EthCrossAccount memory to, uint256 amount) public returns (bool) {516	function mintCross(CrossAccount memory to, uint256 amount) public returns (bool) {
516		require(false, stub_error);517		require(false, stub_error);
517		to;518		to;
518		amount;519		amount;
522523
523	/// @dev EVM selector for this function is: 0x0ecd0ab0,524	/// @dev EVM selector for this function is: 0x0ecd0ab0,
524	///  or in textual repr: approveCross((address,uint256),uint256)525	///  or in textual repr: approveCross((address,uint256),uint256)
525	function approveCross(EthCrossAccount memory spender, uint256 amount) public returns (bool) {526	function approveCross(CrossAccount memory spender, uint256 amount) public returns (bool) {
526		require(false, stub_error);527		require(false, stub_error);
527		spender;528		spender;
528		amount;529		amount;
552	/// @param amount The amount that will be burnt.553	/// @param amount The amount that will be burnt.
553	/// @dev EVM selector for this function is: 0xbb2f5a58,554	/// @dev EVM selector for this function is: 0xbb2f5a58,
554	///  or in textual repr: burnFromCross((address,uint256),uint256)555	///  or in textual repr: burnFromCross((address,uint256),uint256)
555	function burnFromCross(EthCrossAccount memory from, uint256 amount) public returns (bool) {556	function burnFromCross(CrossAccount memory from, uint256 amount) public returns (bool) {
556		require(false, stub_error);557		require(false, stub_error);
557		from;558		from;
558		amount;559		amount;
573574
574	/// @dev EVM selector for this function is: 0x2ada85ff,575	/// @dev EVM selector for this function is: 0x2ada85ff,
575	///  or in textual repr: transferCross((address,uint256),uint256)576	///  or in textual repr: transferCross((address,uint256),uint256)
576	function transferCross(EthCrossAccount memory to, uint256 amount) public returns (bool) {577	function transferCross(CrossAccount memory to, uint256 amount) public returns (bool) {
577		require(false, stub_error);578		require(false, stub_error);
578		to;579		to;
579		amount;580		amount;
584	/// @dev EVM selector for this function is: 0xd5cf430b,585	/// @dev EVM selector for this function is: 0xd5cf430b,
585	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)586	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)
586	function transferFromCross(587	function transferFromCross(
587		EthCrossAccount memory from,588		CrossAccount memory from,
588		EthCrossAccount memory to,589		CrossAccount memory to,
589		uint256 amount590		uint256 amount
590	) public returns (bool) {591	) public returns (bool) {
591		require(false, stub_error);592		require(false, stub_error);

38use pallet_common::{38use pallet_common::{
39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
41	eth::{Property as PropertyStruct, EthCrossAccount},
42};41};
43use pallet_evm::{account::CrossAccountId, PrecompileHandle};42use pallet_evm::{account::CrossAccountId, PrecompileHandle};
44use pallet_evm_coder_substrate::call;43use pallet_evm_coder_substrate::call;
160		&mut self,159		&mut self,
161		caller: caller,160		caller: caller,
162		token_id: uint256,161		token_id: uint256,
163		properties: Vec<PropertyStruct>,162		properties: Vec<pallet_common::eth::Property>,
164	) -> Result<()> {163	) -> Result<()> {
165		let caller = T::CrossAccountId::from_eth(caller);164		let caller = T::CrossAccountId::from_eth(caller);
166		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;165		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
171170
172		let properties = properties171		let properties = properties
173			.into_iter()172			.into_iter()
174			.map(|PropertyStruct { key, value }| {173			.map(|pallet_common::eth::Property { key, value }| {
175				let key = <Vec<u8>>::from(key)174				let key = <Vec<u8>>::from(key)
176					.try_into()175					.try_into()
177					.map_err(|_| "key too large")?;176					.map_err(|_| "key too large")?;
762	/// Returns the owner (in cross format) of the token.761	/// Returns the owner (in cross format) of the token.
763	///762	///
764	/// @param tokenId Id for the token.763	/// @param tokenId Id for the token.
765	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {764	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAccount> {
766		Self::token_owner(&self, token_id.try_into()?)765		Self::token_owner(&self, token_id.try_into()?)
767			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))766			.map(|o| pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(&o))
768			.ok_or(Error::Revert("key too large".into()))767			.ok_or(Error::Revert("key too large".into()))
769	}768	}
770769
773	/// @param tokenId Id for the token.772	/// @param tokenId Id for the token.
774	/// @param keys Properties keys. Empty keys for all propertyes.773	/// @param keys Properties keys. Empty keys for all propertyes.
775	/// @return Vector of properties key/value pairs.774	/// @return Vector of properties key/value pairs.
776	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {775	fn properties(
776		&self,
777		token_id: uint256,
778		keys: Vec<string>,
779	) -> Result<Vec<pallet_common::eth::Property>> {
777		let keys = keys780		let keys = keys
778			.into_iter()781			.into_iter()
779			.map(|key| {782			.map(|key| {
793			let key = string::from_utf8(p.key.to_vec())796			let key = string::from_utf8(p.key.to_vec())
794				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;797				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;
795			let value = bytes(p.value.to_vec());798			let value = bytes(p.value.to_vec());
796			Ok(PropertyStruct { key, value })799			Ok(pallet_common::eth::Property { key, value })
797		})800		})
798		.collect::<Result<Vec<_>>>()801		.collect::<Result<Vec<_>>>()
799	}802	}
808	fn approve_cross(811	fn approve_cross(
809		&mut self,812		&mut self,
810		caller: caller,813		caller: caller,
811		approved: EthCrossAccount,814		approved: pallet_common::eth::CrossAccount,
812		token_id: uint256,815		token_id: uint256,
813	) -> Result<void> {816	) -> Result<void> {
814		let caller = T::CrossAccountId::from_eth(caller);817		let caller = T::CrossAccountId::from_eth(caller);
847	fn transfer_cross(850	fn transfer_cross(
848		&mut self,851		&mut self,
849		caller: caller,852		caller: caller,
850		to: EthCrossAccount,853		to: pallet_common::eth::CrossAccount,
851		token_id: uint256,854		token_id: uint256,
852	) -> Result<void> {855	) -> Result<void> {
853		let caller = T::CrossAccountId::from_eth(caller);856		let caller = T::CrossAccountId::from_eth(caller);
871	fn transfer_from_cross(874	fn transfer_from_cross(
872		&mut self,875		&mut self,
873		caller: caller,876		caller: caller,
874		from: EthCrossAccount,877		from: pallet_common::eth::CrossAccount,
875		to: EthCrossAccount,878		to: pallet_common::eth::CrossAccount,
876		token_id: uint256,879		token_id: uint256,
877	) -> Result<void> {880	) -> Result<void> {
878		let caller = T::CrossAccountId::from_eth(caller);881		let caller = T::CrossAccountId::from_eth(caller);
918	fn burn_from_cross(921	fn burn_from_cross(
919		&mut self,922		&mut self,
920		caller: caller,923		caller: caller,
921		from: EthCrossAccount,924		from: pallet_common::eth::CrossAccount,
922		token_id: uint256,925		token_id: uint256,
923	) -> Result<void> {926	) -> Result<void> {
924		let caller = T::CrossAccountId::from_eth(caller);927		let caller = T::CrossAccountId::from_eth(caller);
1040	fn mint_cross(1043	fn mint_cross(
1041		&mut self,1044		&mut self,
1042		caller: caller,1045		caller: caller,
1043		to: EthCrossAccount,1046		to: pallet_common::eth::CrossAccount,
1044		properties: Vec<PropertyStruct>,1047		properties: Vec<pallet_common::eth::Property>,
1045	) -> Result<uint256> {1048	) -> Result<uint256> {
1046		let token_id = <TokensMinted<T>>::get(self.id)1049		let token_id = <TokensMinted<T>>::get(self.id)
1047			.checked_add(1)1050			.checked_add(1)
10511054
1052		let properties = properties1055		let properties = properties
1053			.into_iter()1056			.into_iter()
1054			.map(|PropertyStruct { key, value }| {1057			.map(|pallet_common::eth::Property { key, value }| {
1055				let key = <Vec<u8>>::from(key)1058				let key = <Vec<u8>>::from(key)
1056					.try_into()1059					.try_into()
1057					.map_err(|_| "key too large")?;1060					.map_err(|_| "key too large")?;