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

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -30,7 +30,6 @@
 	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
 	SponsoringRateLimit, SponsorshipState,
 };
-use alloc::format;
 
 use crate::{
 	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf, eth, weights::WeightInfo,
@@ -123,16 +122,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(|property| {
-				let (key, value) = property.take_key_value();
-				let key = <Vec<u8>>::from(key)
-					.try_into()
-					.map_err(|_| "key too large")?;
-
-				let value = value.0.try_into().map_err(|_| "value too large")?;
-
-				Ok(Property { key, value })
-			})
+			.map(eth::Property::try_into)
 			.collect::<Result<Vec<_>>>()?;
 
 		<Pallet<T>>::set_collection_properties(self, &caller, properties)
@@ -210,12 +200,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(|p| {
-				let key =
-					string::from_utf8(p.key.into()).map_err(|e| Error::Revert(format!("{}", e)))?;
-				let value = bytes(p.value.to_vec());
-				Ok(eth::Property::new(key, value))
-			})
+			.map(Property::try_into)
 			.collect::<Result<Vec<_>>>()?;
 		Ok(properties)
 	}

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -175,13 +175,28 @@
 	value: evm_coder::types::bytes,
 }
 
-impl Property {
-	pub fn new(key: evm_coder::types::string, value: evm_coder::types::bytes) -> Self {
-		Self { key, value }
+impl TryFrom<up_data_structs::Property> for Property {
+	type Error = evm_coder::execution::Error;
+
+	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {
+		let key = evm_coder::types::string::from_utf8(from.key.into())
+			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;
+		let value = evm_coder::types::bytes(from.value.to_vec());
+		Ok(Property { key, value })
 	}
+}
 
-	pub fn take_key_value(self) -> (evm_coder::types::string, evm_coder::types::bytes) {
-		(self.key, self.value)
+impl TryInto<up_data_structs::Property> for Property {
+	type Error = evm_coder::execution::Error;
+
+	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {
+		let key = <Vec<u8>>::from(self.key)
+			.try_into()
+			.map_err(|_| "key too large")?;
+
+		let value = self.value.0.try_into().map_err(|_| "value too large")?;
+
+		Ok(up_data_structs::Property { key, value })
 	}
 }
 

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -170,16 +170,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(|property| {
-				let (key, value) = property.take_key_value();
-				let key = <Vec<u8>>::from(key)
-					.try_into()
-					.map_err(|_| "key too large")?;
-
-				let value = value.0.try_into().map_err(|_| "value too large")?;
-
-				Ok(Property { key, value })
-			})
+			.map(pallet_common::eth::Property::try_into)
 			.collect::<Result<Vec<_>>>()?;
 
 		<Pallet<T>>::set_token_properties(
@@ -793,12 +784,7 @@
 			if keys.is_empty() { None } else { Some(keys) },
 		)
 		.into_iter()
-		.map(|p| {
-			let key = string::from_utf8(p.key.to_vec())
-				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;
-			let value = bytes(p.value.to_vec());
-			Ok(pallet_common::eth::Property::new(key, value))
-		})
+		.map(pallet_common::eth::Property::try_from)
 		.collect::<Result<Vec<_>>>()
 	}
 
@@ -1055,16 +1041,7 @@
 
 		let properties = properties
 			.into_iter()
-			.map(|property| {
-				let (key, value) = property.take_key_value();
-				let key = <Vec<u8>>::from(key)
-					.try_into()
-					.map_err(|_| "key too large")?;
-
-				let value = value.0.try_into().map_err(|_| "value too large")?;
-
-				Ok(Property { key, value })
-			})
+			.map(pallet_common::eth::Property::try_into)
 			.collect::<Result<Vec<_>>>()?
 			.try_into()
 			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;

173173
174		let properties = properties174		let properties = properties
175			.into_iter()175			.into_iter()
176			.map(|property| {176			.map(pallet_common::eth::Property::try_into)
177				let (key, value) = property.take_key_value();
178				let key = <Vec<u8>>::from(key)
179					.try_into()
180					.map_err(|_| "key too large")?;
181
182				let value = value.0.try_into().map_err(|_| "value too large")?;
183
184				Ok(Property { key, value })
185			})
186			.collect::<Result<Vec<_>>>()?;177			.collect::<Result<Vec<_>>>()?;
187178
188		<Pallet<T>>::set_token_properties(179		<Pallet<T>>::set_token_properties(
828			if keys.is_empty() { None } else { Some(keys) },819			if keys.is_empty() { None } else { Some(keys) },
829		)820		)
830		.into_iter()821		.into_iter()
831		.map(|p| {822		.map(pallet_common::eth::Property::try_from)
832			let key = string::from_utf8(p.key.to_vec())
833				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;
834			let value = bytes(p.value.to_vec());
835			Ok(pallet_common::eth::Property::new(key, value))
836		})
837		.collect::<Result<Vec<_>>>()823		.collect::<Result<Vec<_>>>()
838	}824	}
839	/// @notice Transfer ownership of an RFT825	/// @notice Transfer ownership of an RFT
11011087
1102		let properties = properties1088		let properties = properties
1103			.into_iter()1089			.into_iter()
1104			.map(|property| {1090			.map(pallet_common::eth::Property::try_into)
1105				let (key, value) = property.take_key_value();
1106				let key = <Vec<u8>>::from(key)
1107					.try_into()
1108					.map_err(|_| "key too large")?;
1109
1110				let value = value.0.try_into().map_err(|_| "value too large")?;
1111
1112				Ok(Property { key, value })
1113			})
1114			.collect::<Result<Vec<_>>>()?1091			.collect::<Result<Vec<_>>>()?
1115			.try_into()1092			.try_into()
1116			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;1093			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;