`a22e53f08409`

4 files changed

modifiedpallets/common/src/erc.rsdiff before after both

30	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,30	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
31	SponsoringRateLimit, SponsorshipState,31	SponsoringRateLimit, SponsorshipState,
32};32};
33use alloc::format;
3433
35use crate::{34use crate::{
36	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf, eth, weights::WeightInfo,35	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf, eth, weights::WeightInfo,
123122
124		let properties = properties123		let properties = properties
125			.into_iter()124			.into_iter()
126			.map(|property| {125			.map(eth::Property::try_into)
127				let (key, value) = property.take_key_value();
128				let key = <Vec<u8>>::from(key)
129					.try_into()
130					.map_err(|_| "key too large")?;
131
132				let value = value.0.try_into().map_err(|_| "value too large")?;
133
134				Ok(Property { key, value })
135			})
136			.collect::<Result<Vec<_>>>()?;126			.collect::<Result<Vec<_>>>()?;
137127
138		<Pallet<T>>::set_collection_properties(self, &caller, properties)128		<Pallet<T>>::set_collection_properties(self, &caller, properties)
210200
211		let properties = properties201		let properties = properties
212			.into_iter()202			.into_iter()
213			.map(|p| {203			.map(Property::try_into)
214				let key =
215					string::from_utf8(p.key.into()).map_err(|e| Error::Revert(format!("{}", e)))?;
216				let value = bytes(p.value.to_vec());
217				Ok(eth::Property::new(key, value))
218			})
219			.collect::<Result<Vec<_>>>()?;204			.collect::<Result<Vec<_>>>()?;
220		Ok(properties)205		Ok(properties)
221	}206	}

modifiedpallets/common/src/eth.rsdiff before after both

175	value: evm_coder::types::bytes,175	value: evm_coder::types::bytes,
176}176}
177177
178impl Property {178impl TryFrom<up_data_structs::Property> for Property {
179	type Error = evm_coder::execution::Error;
180
179	pub fn new(key: evm_coder::types::string, value: evm_coder::types::bytes) -> Self {181	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {
182		let key = evm_coder::types::string::from_utf8(from.key.into())
183			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;
184		let value = evm_coder::types::bytes(from.value.to_vec());
180		Self { key, value }185		Ok(Property { key, value })
181	}186	}
182
183	pub fn take_key_value(self) -> (evm_coder::types::string, evm_coder::types::bytes) {
184		(self.key, self.value)
185	}
186}187}
188
189impl TryInto<up_data_structs::Property> for Property {
190	type Error = evm_coder::execution::Error;
191
192	fn try_into(self) -> Result<up_data_structs::Property, Self::Error> {
193		let key = <Vec<u8>>::from(self.key)
194			.try_into()
195			.map_err(|_| "key too large")?;
196
197		let value = self.value.0.try_into().map_err(|_| "value too large")?;
198
199		Ok(up_data_structs::Property { key, value })
200	}
201}
187202
188/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.203/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.
189#[derive(Debug, Default, Clone, Copy, AbiCoder)]204#[derive(Debug, Default, Clone, Copy, AbiCoder)]

modifiedpallets/nonfungible/src/erc.rsdiff before after both

170170
171		let properties = properties171		let properties = properties
172			.into_iter()172			.into_iter()
173			.map(|property| {173			.map(pallet_common::eth::Property::try_into)
174				let (key, value) = property.take_key_value();
175				let key = <Vec<u8>>::from(key)
176					.try_into()
177					.map_err(|_| "key too large")?;
178
179				let value = value.0.try_into().map_err(|_| "value too large")?;
180
181				Ok(Property { key, value })
182			})
183			.collect::<Result<Vec<_>>>()?;174			.collect::<Result<Vec<_>>>()?;
184175
185		<Pallet<T>>::set_token_properties(176		<Pallet<T>>::set_token_properties(
793			if keys.is_empty() { None } else { Some(keys) },784			if keys.is_empty() { None } else { Some(keys) },
794		)785		)
795		.into_iter()786		.into_iter()
796		.map(|p| {787		.map(pallet_common::eth::Property::try_from)
797			let key = string::from_utf8(p.key.to_vec())
798				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;
799			let value = bytes(p.value.to_vec());
800			Ok(pallet_common::eth::Property::new(key, value))
801		})
802		.collect::<Result<Vec<_>>>()788		.collect::<Result<Vec<_>>>()
803	}789	}
804790
10551041
1056		let properties = properties1042		let properties = properties
1057			.into_iter()1043			.into_iter()
1058			.map(|property| {1044			.map(pallet_common::eth::Property::try_into)
1059				let (key, value) = property.take_key_value();
1060				let key = <Vec<u8>>::from(key)
1061					.try_into()
1062					.map_err(|_| "key too large")?;
1063
1064				let value = value.0.try_into().map_err(|_| "value too large")?;
1065
1066				Ok(Property { key, value })
1067			})
1068			.collect::<Result<Vec<_>>>()?1045			.collect::<Result<Vec<_>>>()?
1069			.try_into()1046			.try_into()
1070			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;1047			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;

modifiedpallets/refungible/src/erc.rsdiff before after both

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")))?;