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

--- a/crates/evm-coder-macros/src/solidity_interface.rs
+++ b/crates/evm-coder-macros/src/solidity_interface.rs
@@ -23,6 +23,7 @@
 use syn::{
 	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
 	MetaNameValue, NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,
+	parse_str,
 };
 
 use crate::{
@@ -35,16 +36,21 @@
 	name: Ident,
 	pascal_call_name: Ident,
 	snake_call_name: Ident,
+	via: Option<(Type, Ident)>,
 }
 impl Is {
-	fn try_from(path: &Path) -> syn::Result<Self> {
+	fn new_via(path: &Path, via: Option<(Type, Ident)>) -> syn::Result<Self> {
 		let name = parse_ident_from_path(path, false)?.clone();
 		Ok(Self {
 			pascal_call_name: pascal_ident_to_call(&name),
 			snake_call_name: pascal_ident_to_snake_call(&name),
 			name,
+			via,
 		})
 	}
+	fn new(path: &Path) -> syn::Result<Self> {
+		Self::new_via(path, None)
+	}
 
 	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
 		let name = &self.name;
@@ -85,8 +91,18 @@
 	) -> proc_macro2::TokenStream {
 		let name = &self.name;
 		let pascal_call_name = &self.pascal_call_name;
+		let via_typ = self
+			.via
+			.as_ref()
+			.map(|(t, _)| quote! {#t})
+			.unwrap_or_else(|| quote! {Self});
+		let via_map = self
+			.via
+			.as_ref()
+			.map(|(_, i)| quote! {.#i()})
+			.unwrap_or_default();
 		quote! {
-			#call_name::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self, Msg {
+			#call_name::#name(call) => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {
 				call,
 				caller: c.caller,
 				value: c.value,
@@ -126,8 +142,46 @@
 		let mut out = Vec::new();
 		for item in items {
 			match item {
-				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),
-				_ => return Err(syn::Error::new(item.span(), "expected path").into()),
+				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::new(path)?),
+				// TODO: replace meta parsing with manual
+				NestedMeta::Meta(Meta::List(list))
+					if list.path.is_ident("via") && list.nested.len() == 3 =>
+				{
+					let mut data = list.nested.iter();
+					let typ = match data.next().expect("len == 3") {
+						NestedMeta::Lit(Lit::Str(s)) => {
+							let v = s.value();
+							let typ: Type = parse_str(&v)?;
+							typ
+						}
+						_ => {
+							return Err(syn::Error::new(
+								item.span(),
+								"via typ should be type in string",
+							)
+							.into())
+						}
+					};
+					let via = match data.next().expect("len == 3") {
+						NestedMeta::Meta(Meta::Path(path)) => path
+							.get_ident()
+							.ok_or_else(|| syn::Error::new(item.span(), "via should be ident"))?,
+						_ => return Err(syn::Error::new(item.span(), "via should be ident").into()),
+					};
+					let path = match data.next().expect("len == 3") {
+						NestedMeta::Meta(Meta::Path(path)) => path,
+						_ => return Err(syn::Error::new(item.span(), "path should be path").into()),
+					};
+
+					out.push(Is::new_via(path, Some((typ, via.clone())))?)
+				}
+				_ => {
+					return Err(syn::Error::new(
+						item.span(),
+						"expected either Name or via(\"Type\", getter, Name)",
+					)
+					.into())
+				}
 			}
 		}
 		Ok(Self(out))

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -14,9 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-pub use pallet_evm::PrecompileOutput;
-pub use pallet_evm::PrecompileResult;
+use evm_coder::{solidity_interface, types::*, execution::Result};
+pub use pallet_evm::{PrecompileOutput, PrecompileResult, account::CrossAccountId};
+use pallet_evm_coder_substrate::dispatch_to_evm;
 use sp_core::{H160, U256};
+use sp_std::vec::Vec;
+use up_data_structs::Property;
+
+use crate::{Pallet, CollectionHandle, Config};
 
 /// Does not always represent a full collection, for RFT it is either
 /// collection (Implementing ERC721), or specific collection token (Implementing ERC20)
@@ -25,3 +30,27 @@
 
 	fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileResult>;
 }
+
+#[solidity_interface(name = "CollectionProperties")]
+impl<T: Config> CollectionHandle<T> {
+	fn set_property(&mut self, caller: caller, key: string, value: string) -> Result<()> {
+		<Pallet<T>>::set_collection_property(
+			self,
+			&T::CrossAccountId::from_eth(caller),
+			Property {
+				key: <Vec<u8>>::from(key)
+					.try_into()
+					.map_err(|_| "key too large")?,
+				value: <Vec<u8>>::from(value)
+					.try_into()
+					.map_err(|_| "value too large")?,
+			},
+		)
+		.map_err(dispatch_to_evm::<T>)?;
+		Ok(())
+	}
+
+	fn delete_property(&mut self, caller: caller, key: string) -> Result<()> {
+		self.set_property(caller, key, string::new())
+	}
+}

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -595,7 +595,7 @@
 			.iter()
 			.map(|(key, value)| Property {
 				key: key.clone(),
-				value: value.clone()
+				value: value.clone(),
 			})
 			.collect();
 
@@ -680,19 +680,20 @@
 		};
 
 		let mut collection_properties = up_data_structs::CollectionProperties::get();
-		collection_properties.try_set_from_iter(
-			data.properties.into_iter()
-				.map(|p| (p.key, p.value))
-		).map_err(|e| -> Error<T> { e.into() })?;
+		collection_properties
+			.try_set_from_iter(data.properties.into_iter().map(|p| (p.key, p.value)))
+			.map_err(|e| -> Error<T> { e.into() })?;
 
 		CollectionProperties::<T>::insert(id, collection_properties);
 
 		let mut token_props_permissions = PropertiesPermissionMap::new();
-		token_props_permissions.try_set_from_iter(
-			data.token_property_permissions
-			.into_iter()
-			.map(|property| (property.key, property.permission))
-		).map_err(|e| -> Error<T> { e.into() })?;
+		token_props_permissions
+			.try_set_from_iter(
+				data.token_property_permissions
+					.into_iter()
+					.map(|property| (property.key, property.permission)),
+			)
+			.map_err(|e| -> Error<T> { e.into() })?;
 
 		CollectionPropertyPermissions::<T>::insert(id, token_props_permissions);
 
@@ -806,7 +807,8 @@
 
 		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
 			properties.remove(&property_key)
-		}).map_err(|e| -> Error<T> { e.into() })?;
+		})
+		.map_err(|e| -> Error<T> { e.into() })?;
 
 		Self::deposit_event(Event::CollectionPropertyDeleted(
 			collection.id,
@@ -903,11 +905,10 @@
 		let properties = keys
 			.into_iter()
 			.filter_map(|key| {
-				properties.get(&key)
-					.map(|value| Property {
-						key,
-						value: value.clone(),
-					})
+				properties.get(&key).map(|value| Property {
+					key,
+					value: value.clone(),
+				})
 			})
 			.collect();
 

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -24,6 +24,7 @@
 use pallet_evm::account::CrossAccountId;
 use pallet_evm_coder_substrate::{call, dispatch_to_evm};
 use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
+use pallet_common::{CollectionHandle, erc::CollectionPropertiesCall};
 
 use crate::{
 	Allowance, Balance, Config, FungibleHandle, Pallet, SelfWeightOf, TotalSupply,
@@ -144,7 +145,14 @@
 	}
 }
 
-#[solidity_interface(name = "UniqueFungible", is(ERC20))]
+#[solidity_interface(
+	name = "UniqueFungible",
+	is(
+		ERC20,
+		ERC20UniqueExtensions,
+		via("CollectionHandle<T>", common_mut, CollectionProperties)
+	)
+)]
 impl<T: Config> FungibleHandle<T> {}
 
 generate_stubgen!(gen_impl, UniqueFungibleCall<()>, true);

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -110,6 +110,9 @@
 	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {
 		self.0
 	}
+	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {
+		&mut self.0
+	}
 }
 impl<T: Config> WithRecorder<T> for FungibleHandle<T> {
 	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {

--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -391,11 +391,10 @@
 
 		keys.into_iter()
 			.filter_map(|key| {
-				properties.get(&key)
-					.map(|value| Property {
-						key,
-						value: value.clone(),
-					})
+				properties.get(&key).map(|value| Property {
+					key,
+					value: value.clone(),
+				})
 			})
 			.collect()
 	}

26use sp_core::{H160, U256};26use sp_core::{H160, U256};
27use sp_std::{vec::Vec, vec};27use sp_std::{vec::Vec, vec};
28use pallet_common::{28use pallet_common::{
29	erc::{CommonEvmHandler, PrecompileResult},29	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},
30	CollectionHandle,
30};31};
31use pallet_evm::account::CrossAccountId;32use pallet_evm::account::CrossAccountId;
32use pallet_evm_coder_substrate::call;33use pallet_evm_coder_substrate::call;
504		ERC721UniqueExtensions,505		ERC721UniqueExtensions,
505		ERC721Mintable,506		ERC721Mintable,
506		ERC721Burnable,507		ERC721Burnable,
508		via("CollectionHandle<T>", common_mut, CollectionProperties)
507	)509	)
508)]510)]
509impl<T: Config> NonfungibleHandle<T> {}511impl<T: Config> NonfungibleHandle<T> {}

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -142,6 +142,9 @@
 	pub fn into_inner(self) -> pallet_common::CollectionHandle<T> {
 		self.0
 	}
+	pub fn common_mut(&mut self) -> &mut pallet_common::CollectionHandle<T> {
+		&mut self.0
+	}
 }
 impl<T: Config> WithRecorder<T> for NonfungibleHandle<T> {
 	fn recorder(&self) -> &SubstrateRecorder<T> {
@@ -302,7 +305,8 @@
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			properties.remove(&property_key)
-		}).map_err(|e| -> CommonError<T> { e.into() })?;
+		})
+		.map_err(|e| -> CommonError<T> { e.into() })?;
 
 		<PalletCommon<T>>::deposit_event(CommonEvent::TokenPropertyDeleted(
 			collection.id,

--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -699,7 +699,7 @@
 
 	fn try_set_from_iter<I>(&mut self, iter: I) -> Result<(), PropertiesError>
 	where
-		I: Iterator<Item=(PropertyKey, Self::Value)>
+		I: Iterator<Item = (PropertyKey, Self::Value)>,
 	{
 		for (key, value) in iter {
 			self.try_set(key, value)?;
@@ -711,7 +711,9 @@
 
 #[derive(Encode, Decode, TypeInfo, Derivative, Clone, PartialEq, MaxEncodedLen)]
 #[derivative(Default(bound = ""))]
-pub struct PropertiesMap<Value>(BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>);
+pub struct PropertiesMap<Value>(
+	BoundedBTreeMap<PropertyKey, Value, ConstU32<MAX_PROPERTIES_PER_ITEM>>,
+);
 
 impl<Value> PropertiesMap<Value> {
 	pub fn new() -> Self {