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

--- a/crates/evm-coder/procedural/src/abi_derive/derive_enum.rs
+++ b/crates/evm-coder/procedural/src/abi_derive/derive_enum.rs
@@ -47,11 +47,10 @@
 	)
 }
 
-pub fn impl_enum_abi_type(name: &syn::Ident, option_count: usize) -> proc_macro2::TokenStream {
+pub fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {
 	quote! {
 		impl ::evm_coder::abi::AbiType for #name {
 			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;
-			const FIELDS_COUNT: usize = #option_count;
 
 			fn is_dynamic() -> bool {
 				<u8 as ::evm_coder::abi::AbiType>::is_dynamic()

--- a/crates/evm-coder/procedural/src/abi_derive/derive_struct.rs
+++ b/crates/evm-coder/procedural/src/abi_derive/derive_struct.rs
@@ -100,12 +100,10 @@
 pub fn impl_struct_abi_type(
 	name: &syn::Ident,
 	tuple_type: proc_macro2::TokenStream,
-	fields_count: usize,
 ) -> proc_macro2::TokenStream {
 	quote! {
 		impl ::evm_coder::abi::AbiType for #name {
 			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;
-			const FIELDS_COUNT: usize = #fields_count;
 			fn is_dynamic() -> bool {
 				<#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()
 			}

--- a/crates/evm-coder/procedural/src/abi_derive/mod.rs
+++ b/crates/evm-coder/procedural/src/abi_derive/mod.rs
@@ -49,7 +49,7 @@
 	let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());
 
 	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
-	let abi_type = impl_struct_abi_type(name, tuple_type.clone(), params_count);
+	let abi_type = impl_struct_abi_type(name, tuple_type.clone());
 	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);
 	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);
 	let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);
@@ -83,7 +83,7 @@
 	let from = impl_enum_from_u8(name, enum_options.clone());
 	let solidity_option = impl_solidity_option(name, enum_options.clone());
 	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
-	let abi_type = impl_enum_abi_type(name, option_count);
+	let abi_type = impl_enum_abi_type(name);
 	let abi_read = impl_enum_abi_read(name);
 	let abi_write = impl_enum_abi_write(name);
 	let solidity_type = impl_enum_solidity_type(name);

--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -16,7 +16,6 @@
 
 		impl AbiType for $ty {
 			const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($name)));
-			const FIELDS_COUNT: usize = 1;
 
 			fn is_dynamic() -> bool {
 				$dynamic
@@ -97,7 +96,6 @@
 
 impl<T: AbiType> AbiType for &T {
 	const SIGNATURE: SignatureUnit = T::SIGNATURE;
-	const FIELDS_COUNT: usize = T::FIELDS_COUNT;
 
 	fn is_dynamic() -> bool {
 		T::is_dynamic()
@@ -127,7 +125,6 @@
 
 impl<T: AbiType> AbiType for Vec<T> {
 	const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));
-	const FIELDS_COUNT: usize = 1;
 
 	fn is_dynamic() -> bool {
 		true
@@ -203,7 +200,6 @@
                 shift_left(1)
                 fixed(")")
             );
-			const FIELDS_COUNT: usize = count!($($ident)*);
 
 			fn is_dynamic() -> bool {
 				false

--- a/crates/evm-coder/src/abi/traits.rs
+++ b/crates/evm-coder/src/abi/traits.rs
@@ -10,9 +10,6 @@
 	/// Signature for Etherium ABI.
 	const SIGNATURE: SignatureUnit;
 
-	/// Count of enum variants or struct fields.
-	const FIELDS_COUNT: usize;
-
 	/// Signature as str.
 	fn as_str() -> &'static str {
 		from_utf8(&Self::SIGNATURE.data[..Self::SIGNATURE.len]).expect("bad utf-8")

--- a/crates/evm-coder/tests/abi_derive_generation.rs
+++ b/crates/evm-coder/tests/abi_derive_generation.rs
@@ -173,50 +173,6 @@
 	}
 
 	#[test]
-	fn impl_abi_type_fields_count() {
-		assert_eq!(
-			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			1
-		);
-		assert_eq!(
-			<TypeStruct1DynamicParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			1
-		);
-		assert_eq!(
-			<TypeStruct2SimpleParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			2
-		);
-		assert_eq!(
-			<TypeStruct2DynamicParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			2
-		);
-		assert_eq!(
-			<TypeStruct2MixedParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			2
-		);
-		assert_eq!(
-			<TypeStruct1DerivedSimpleParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			1
-		);
-		assert_eq!(
-			<TypeStruct2DerivedSimpleParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			2
-		);
-		assert_eq!(
-			<TypeStruct1DerivedDynamicParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			1
-		);
-		assert_eq!(
-			<TypeStruct2DerivedDynamicParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			2
-		);
-		assert_eq!(
-			<TypeStruct3DerivedMixedParam as evm_coder::abi::AbiType>::FIELDS_COUNT,
-			3
-		);
-	}
-
-	#[test]
 	fn impl_abi_type_is_dynamic() {
 		assert_eq!(
 			<TypeStruct1SimpleParam as evm_coder::abi::AbiType>::is_dynamic(),

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -347,6 +347,10 @@
 	) -> Result<void> {
 		self.consume_store_reads_and_writes(1, 1)?;
 
+		if !limit.has_value() {
+			return Err(Error::Revert("user can't disable limits".into()));
+		}
+
 		let caller = T::CrossAccountId::from_eth(caller);
 		<Pallet<T>>::update_limits(&caller, self, limit.try_into()?).map_err(dispatch_to_evm::<T>)
 	}

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -264,16 +264,17 @@
 			value: value.into(),
 		}
 	}
+
+	/// Whether the field contains a value.
+	pub fn has_value(&self) -> bool {
+		self.value.status
+	}
 }
 
 impl TryInto<up_data_structs::CollectionLimits> for CollectionLimit {
 	type Error = evm_coder::execution::Error;
 
 	fn try_into(self) -> Result<up_data_structs::CollectionLimits, Self::Error> {
-		if !self.value.status {
-			return Err(Self::Error::Revert("user can't disable limits".into()));
-		}
-
 		let value = self.value.value.try_into().map_err(|error| {
 			Self::Error::Revert(format!(
 				"can't convert value to u32 \"{}\" because: \"{error}\"",
@@ -433,17 +434,6 @@
 		let mut perms = Vec::new();
 
 		for TokenPropertyPermission { key, permissions } in permissions {
-			if permissions.len() > <TokenPermissionField as evm_coder::abi::AbiType>::FIELDS_COUNT {
-				return Err(alloc::format!(
-					"Actual number of fields {} for {}, which exceeds the maximum value of {}",
-					permissions.len(),
-					stringify!(EthTokenPermissions),
-					<TokenPermissionField as evm_coder::abi::AbiType>::FIELDS_COUNT
-				)
-				.as_str()
-				.into());
-			}
-
 			let token_permission = PropertyPermission::from_vec(permissions);
 
 			perms.push(up_data_structs::PropertyKeyPermission {

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,
41};42};
42use pallet_evm::{account::CrossAccountId, PrecompileHandle};43use pallet_evm::{account::CrossAccountId, PrecompileHandle};
43use pallet_evm_coder_substrate::call;44use pallet_evm_coder_substrate::call;
93	fn set_token_property_permissions(94	fn set_token_property_permissions(
94		&mut self,95		&mut self,
95		caller: caller,96		caller: caller,
96		permissions: Vec<pallet_common::eth::TokenPropertyPermission>,97		permissions: Vec<eth::TokenPropertyPermission>,
97	) -> Result<()> {98	) -> Result<()> {
98		let caller = T::CrossAccountId::from_eth(caller);99		let caller = T::CrossAccountId::from_eth(caller);
99		let perms = pallet_common::eth::TokenPropertyPermission::into_property_key_permissions(100		let perms = eth::TokenPropertyPermission::into_property_key_permissions(permissions)?;
100			permissions,
101		)?;
102101
107	/// @notice Get permissions for token properties.106	/// @notice Get permissions for token properties.
108	fn token_property_permissions(107	fn token_property_permissions(&self) -> Result<Vec<eth::TokenPropertyPermission>> {
109		&self,
110	) -> Result<Vec<pallet_common::eth::TokenPropertyPermission>> {
111		let perms = <Pallet<T>>::token_property_permission(self.id);108		let perms = <Pallet<T>>::token_property_permission(self.id);
112		Ok(perms109		Ok(perms
113			.into_iter()110			.into_iter()
114			.map(pallet_common::eth::TokenPropertyPermission::from)111			.map(eth::TokenPropertyPermission::from)
115			.collect())112			.collect())
116	}113	}
117114
159		&mut self,156		&mut self,
160		caller: caller,157		caller: caller,
161		token_id: uint256,158		token_id: uint256,
162		properties: Vec<pallet_common::eth::Property>,159		properties: Vec<eth::Property>,
163	) -> Result<()> {160	) -> Result<()> {
164		let caller = T::CrossAccountId::from_eth(caller);161		let caller = T::CrossAccountId::from_eth(caller);
165		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;162		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
170167
171		let properties = properties168		let properties = properties
172			.into_iter()169			.into_iter()
173			.map(pallet_common::eth::Property::try_into)170			.map(eth::Property::try_into)
174			.collect::<Result<Vec<_>>>()?;171			.collect::<Result<Vec<_>>>()?;
175172
176		<Pallet<T>>::set_token_properties(173		<Pallet<T>>::set_token_properties(
753	/// Returns the owner (in cross format) of the token.750	/// Returns the owner (in cross format) of the token.
754	///751	///
755	/// @param tokenId Id for the token.752	/// @param tokenId Id for the token.
756	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {753	fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
757		Self::token_owner(&self, token_id.try_into()?)754		Self::token_owner(&self, token_id.try_into()?)
758			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))755			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
759			.ok_or(Error::Revert("key too large".into()))756			.ok_or(Error::Revert("key too large".into()))
760	}757	}
761758
768		&self,
769		token_id: uint256,
770		keys: Vec<string>,
771	) -> Result<Vec<pallet_common::eth::Property>> {
772		let keys = keys765		let keys = keys
773			.into_iter()766			.into_iter()
774			.map(|key| {767			.map(|key| {
784			if keys.is_empty() { None } else { Some(keys) },777			if keys.is_empty() { None } else { Some(keys) },
785		)778		)
786		.into_iter()779		.into_iter()
787		.map(pallet_common::eth::Property::try_from)780		.map(eth::Property::try_from)
788		.collect::<Result<Vec<_>>>()781		.collect::<Result<Vec<_>>>()
789	}782	}
790783
798	fn approve_cross(791	fn approve_cross(
799		&mut self,792		&mut self,
800		caller: caller,793		caller: caller,
801		approved: pallet_common::eth::CrossAddress,794		approved: eth::CrossAddress,
802		token_id: uint256,795		token_id: uint256,
803	) -> Result<void> {796	) -> Result<void> {
804		let caller = T::CrossAccountId::from_eth(caller);797		let caller = T::CrossAccountId::from_eth(caller);
837	fn transfer_cross(830	fn transfer_cross(
838		&mut self,831		&mut self,
839		caller: caller,832		caller: caller,
840		to: pallet_common::eth::CrossAddress,833		to: eth::CrossAddress,
841		token_id: uint256,834		token_id: uint256,
842	) -> Result<void> {835	) -> Result<void> {
843		let caller = T::CrossAccountId::from_eth(caller);836		let caller = T::CrossAccountId::from_eth(caller);
861	fn transfer_from_cross(854	fn transfer_from_cross(
862		&mut self,855		&mut self,
863		caller: caller,856		caller: caller,
864		from: pallet_common::eth::CrossAddress,857		from: eth::CrossAddress,
865		to: pallet_common::eth::CrossAddress,858		to: eth::CrossAddress,
866		token_id: uint256,859		token_id: uint256,
867	) -> Result<void> {860	) -> Result<void> {
868		let caller = T::CrossAccountId::from_eth(caller);861		let caller = T::CrossAccountId::from_eth(caller);
908	fn burn_from_cross(901	fn burn_from_cross(
909		&mut self,902		&mut self,
910		caller: caller,903		caller: caller,
911		from: pallet_common::eth::CrossAddress,904		from: eth::CrossAddress,
912		token_id: uint256,905		token_id: uint256,
913	) -> Result<void> {906	) -> Result<void> {
914		let caller = T::CrossAccountId::from_eth(caller);907		let caller = T::CrossAccountId::from_eth(caller);
1030	fn mint_cross(1023	fn mint_cross(
1031		&mut self,1024		&mut self,
1032		caller: caller,1025		caller: caller,
1033		to: pallet_common::eth::CrossAddress,1026		to: eth::CrossAddress,
1034		properties: Vec<pallet_common::eth::Property>,1027		properties: Vec<eth::Property>,
1035	) -> Result<uint256> {1028	) -> Result<uint256> {
1036		let token_id = <TokensMinted<T>>::get(self.id)1029		let token_id = <TokensMinted<T>>::get(self.id)
1037			.checked_add(1)1030			.checked_add(1)
10411034
1042		let properties = properties1035		let properties = properties
1043			.into_iter()1036			.into_iter()
1044			.map(pallet_common::eth::Property::try_into)1037			.map(eth::Property::try_into)
1045			.collect::<Result<Vec<_>>>()?1038			.collect::<Result<Vec<_>>>()?
1046			.try_into()1039			.try_into()
1047			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;1040			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -32,8 +32,9 @@
 use frame_support::{BoundedBTreeMap, BoundedVec};
 use pallet_common::{
 	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
+	Error as CommonError,
 	erc::{CommonEvmHandler, CollectionCall, static_property::key},
-	Error as CommonError,
+	eth,
 };
 use pallet_evm::{account::CrossAccountId, PrecompileHandle};
 use pallet_evm_coder_substrate::{call, dispatch_to_evm};
@@ -96,25 +97,21 @@
 	fn set_token_property_permissions(
 		&mut self,
 		caller: caller,
-		permissions: Vec<pallet_common::eth::TokenPropertyPermission>,
+		permissions: Vec<eth::TokenPropertyPermission>,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
-		let perms = pallet_common::eth::TokenPropertyPermission::into_property_key_permissions(
-			permissions,
-		)?;
+		let perms = eth::TokenPropertyPermission::into_property_key_permissions(permissions)?;
 
 		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)
 			.map_err(dispatch_to_evm::<T>)
 	}
 
 	/// @notice Get permissions for token properties.
-	fn token_property_permissions(
-		&self,
-	) -> Result<Vec<pallet_common::eth::TokenPropertyPermission>> {
+	fn token_property_permissions(&self) -> Result<Vec<eth::TokenPropertyPermission>> {
 		let perms = <Pallet<T>>::token_property_permission(self.id);
 		Ok(perms
 			.into_iter()
-			.map(pallet_common::eth::TokenPropertyPermission::from)
+			.map(eth::TokenPropertyPermission::from)
 			.collect())
 	}
 
@@ -162,7 +159,7 @@
 		&mut self,
 		caller: caller,
 		token_id: uint256,
-		properties: Vec<pallet_common::eth::Property>,
+		properties: Vec<eth::Property>,
 	) -> Result<()> {
 		let caller = T::CrossAccountId::from_eth(caller);
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -173,7 +170,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(pallet_common::eth::Property::try_into)
+			.map(eth::Property::try_into)
 			.collect::<Result<Vec<_>>>()?;
 
 		<Pallet<T>>::set_token_properties(
@@ -788,9 +785,9 @@
 	/// Returns the owner (in cross format) of the token.
 	///
 	/// @param tokenId Id for the token.
-	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {
+	fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {
 		Self::token_owner(&self, token_id.try_into()?)
-			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))
+			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
 			.ok_or(Error::Revert("key too large".into()))
 	}
 
@@ -799,11 +796,7 @@
 	/// @param tokenId Id for the token.
 	/// @param keys Properties keys. Empty keys for all propertyes.
 	/// @return Vector of properties key/value pairs.
-	fn properties(
-		&self,
-		token_id: uint256,
-		keys: Vec<string>,
-	) -> Result<Vec<pallet_common::eth::Property>> {
+	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {
 		let keys = keys
 			.into_iter()
 			.map(|key| {
@@ -819,7 +812,7 @@
 			if keys.is_empty() { None } else { Some(keys) },
 		)
 		.into_iter()
-		.map(pallet_common::eth::Property::try_from)
+		.map(eth::Property::try_from)
 		.collect::<Result<Vec<_>>>()
 	}
 	/// @notice Transfer ownership of an RFT
@@ -855,7 +848,7 @@
 	fn transfer_cross(
 		&mut self,
 		caller: caller,
-		to: pallet_common::eth::CrossAddress,
+		to: eth::CrossAddress,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -883,8 +876,8 @@
 	fn transfer_from_cross(
 		&mut self,
 		caller: caller,
-		from: pallet_common::eth::CrossAddress,
-		to: pallet_common::eth::CrossAddress,
+		from: eth::CrossAddress,
+		to: eth::CrossAddress,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -939,7 +932,7 @@
 	fn burn_from_cross(
 		&mut self,
 		caller: caller,
-		from: pallet_common::eth::CrossAddress,
+		from: eth::CrossAddress,
 		token_id: uint256,
 	) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -1076,8 +1069,8 @@
 	fn mint_cross(
 		&mut self,
 		caller: caller,
-		to: pallet_common::eth::CrossAddress,
-		properties: Vec<pallet_common::eth::Property>,
+		to: eth::CrossAddress,
+		properties: Vec<eth::Property>,
 	) -> Result<uint256> {
 		let token_id = <TokensMinted<T>>::get(self.id)
 			.checked_add(1)
@@ -1087,7 +1080,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(pallet_common::eth::Property::try_into)
+			.map(eth::Property::try_into)
 			.collect::<Result<Vec<_>>>()?
 			.try_into()
 			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;