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

23use syn::{23use syn::{
24	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,24	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
25	MetaNameValue, NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,25	MetaNameValue, NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,
26	parse_str,
26};27};
2728
28use crate::{29use crate::{
35	name: Ident,36	name: Ident,
36	pascal_call_name: Ident,37	pascal_call_name: Ident,
37	snake_call_name: Ident,38	snake_call_name: Ident,
39	via: Option<(Type, Ident)>,
38}40}
39impl Is {41impl Is {
40	fn try_from(path: &Path) -> syn::Result<Self> {42	fn new_via(path: &Path, via: Option<(Type, Ident)>) -> syn::Result<Self> {
41		let name = parse_ident_from_path(path, false)?.clone();43		let name = parse_ident_from_path(path, false)?.clone();
42		Ok(Self {44		Ok(Self {
43			pascal_call_name: pascal_ident_to_call(&name),45			pascal_call_name: pascal_ident_to_call(&name),
44			snake_call_name: pascal_ident_to_snake_call(&name),46			snake_call_name: pascal_ident_to_snake_call(&name),
45			name,47			name,
48			via,
46		})49		})
47	}50	}
51	fn new(path: &Path) -> syn::Result<Self> {
52		Self::new_via(path, None)
53	}
4854
49	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {55	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
50		let name = &self.name;56		let name = &self.name;
85	) -> proc_macro2::TokenStream {91	) -> proc_macro2::TokenStream {
86		let name = &self.name;92		let name = &self.name;
87		let pascal_call_name = &self.pascal_call_name;93		let pascal_call_name = &self.pascal_call_name;
94		let via_typ = self
95			.via
96			.as_ref()
97			.map(|(t, _)| quote! {#t})
98			.unwrap_or_else(|| quote! {Self});
99		let via_map = self
100			.via
101			.as_ref()
102			.map(|(_, i)| quote! {.#i()})
103			.unwrap_or_default();
88		quote! {104		quote! {
89			#call_name::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self, Msg {105			#call_name::#name(call) => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {
90				call,106				call,
91				caller: c.caller,107				caller: c.caller,
92				value: c.value,108				value: c.value,
126		let mut out = Vec::new();142		let mut out = Vec::new();
127		for item in items {143		for item in items {
128			match item {144			match item {
129				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),145				NestedMeta::Meta(Meta::Path(path)) => out.push(Is::new(path)?),
146				// TODO: replace meta parsing with manual
147				NestedMeta::Meta(Meta::List(list))
148					if list.path.is_ident("via") && list.nested.len() == 3 =>
149				{
150					let mut data = list.nested.iter();
151					let typ = match data.next().expect("len == 3") {
152						NestedMeta::Lit(Lit::Str(s)) => {
153							let v = s.value();
154							let typ: Type = parse_str(&v)?;
155							typ
156						}
130				_ => return Err(syn::Error::new(item.span(), "expected path").into()),157						_ => {
158							return Err(syn::Error::new(
159								item.span(),
160								"via typ should be type in string",
161							)
162							.into())
163						}
164					};
165					let via = match data.next().expect("len == 3") {
166						NestedMeta::Meta(Meta::Path(path)) => path
167							.get_ident()
168							.ok_or_else(|| syn::Error::new(item.span(), "via should be ident"))?,
169						_ => return Err(syn::Error::new(item.span(), "via should be ident").into()),
170					};
171					let path = match data.next().expect("len == 3") {
172						NestedMeta::Meta(Meta::Path(path)) => path,
173						_ => return Err(syn::Error::new(item.span(), "path should be path").into()),
174					};
175
176					out.push(Is::new_via(path, Some((typ, via.clone())))?)
177				}
178				_ => {
179					return Err(syn::Error::new(
180						item.span(),
181						"expected either Name or via(\"Type\", getter, Name)",
182					)
183					.into())
184				}
131			}185			}
132		}186		}
133		Ok(Self(out))187		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()
 	}

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -26,7 +26,8 @@
 use sp_core::{H160, U256};
 use sp_std::{vec::Vec, vec};
 use pallet_common::{
-	erc::{CommonEvmHandler, PrecompileResult},
+	erc::{CommonEvmHandler, PrecompileResult, CollectionPropertiesCall},
+	CollectionHandle,
 };
 use pallet_evm::account::CrossAccountId;
 use pallet_evm_coder_substrate::call;
@@ -504,6 +505,7 @@
 		ERC721UniqueExtensions,
 		ERC721Mintable,
 		ERC721Burnable,
+		via("CollectionHandle<T>", common_mut, CollectionProperties)
 	)
 )]
 impl<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 {