git.delta.rocks / unique-network / refs/commits / 9c9035103c33

211pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {211pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {
212	stream212	stream
213}213}
214#[proc_macro_attribute]
215pub fn weight(_args: TokenStream, stream: TokenStream) -> TokenStream {
216	stream
217}
214218
215#[proc_macro_derive(ToLog, attributes(indexed))]219#[proc_macro_derive(ToLog, attributes(indexed))]
216pub fn to_log(value: TokenStream) -> TokenStream {220pub fn to_log(value: TokenStream) -> TokenStream {

30		})30		})
31	}31	}
3232
33	fn expand_call_def(&self) -> proc_macro2::TokenStream {33	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
34		let name = &self.name;34		let name = &self.name;
35		let pascal_call_name = &self.pascal_call_name;35		let pascal_call_name = &self.pascal_call_name;
36		quote! {36		quote! {
37			#name(#pascal_call_name)37			#name(#pascal_call_name #gen_ref)
38		}38		}
39	}39	}
4040
46	}46	}
4747
48	fn expand_supports_interface(&self) -> proc_macro2::TokenStream {48	fn expand_supports_interface(
49		&self,
50		generics: &proc_macro2::TokenStream,
51	) -> proc_macro2::TokenStream {
49		let pascal_call_name = &self.pascal_call_name;52		let pascal_call_name = &self.pascal_call_name;
50		quote! {53		quote! {
51			#pascal_call_name::supports_interface(interface_id)54			<#pascal_call_name #generics>::supports_interface(interface_id)
52		}55		}
53	}56	}
57
58	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {
59		let name = &self.name;
60		quote! {
61			Self::#name(call) => call.weight()
62		}
63	}
5464
55	fn expand_variant_call(&self) -> proc_macro2::TokenStream {65	fn expand_variant_call(
66		&self,
67		call_name: &proc_macro2::Ident,
68		generics: &proc_macro2::TokenStream,
69	) -> proc_macro2::TokenStream {
56		let name = &self.name;70		let name = &self.name;
57		let pascal_call_name = &self.pascal_call_name;71		let pascal_call_name = &self.pascal_call_name;
58		quote! {72		quote! {
59			InternalCall::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name>>::call(self, Msg {73			#call_name::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self, Msg {
60				call,74				call,
61				caller: c.caller,75				caller: c.caller,
62				value: c.value,76				value: c.value,
63			})77			})
64		}78		}
65	}79	}
6680
67	fn expand_parse(&self) -> proc_macro2::TokenStream {81	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
68		let name = &self.name;82		let name = &self.name;
69		let pascal_call_name = &self.pascal_call_name;83		let pascal_call_name = &self.pascal_call_name;
70		quote! {84		quote! {
71			if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {85			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {
72				return Ok(Some(Self::#name(parsed_call)))86				return Ok(Some(Self::#name(parsed_call)))
73			}87			}
74		}88		}
75	}89	}
7690
77	fn expand_generator(&self) -> proc_macro2::TokenStream {91	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {
78		let pascal_call_name = &self.pascal_call_name;92		let pascal_call_name = &self.pascal_call_name;
79		quote! {93		quote! {
80			#pascal_call_name::generate_solidity_interface(tc, is_impl);94			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);
81		}95		}
82	}96	}
8397
351	Pure,365	Pure,
352}366}
367
368pub struct WeightAttr(syn::Expr);
369
370mod keyword {
371	syn::custom_keyword!(weight);
372}
373
374impl syn::parse::Parse for WeightAttr {
375	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
376		input.parse::<syn::Token![#]>()?;
377		let content;
378		syn::bracketed!(content in input);
379		content.parse::<keyword::weight>()?;
380
381		let weight_content;
382		syn::parenthesized!(weight_content in content);
383		Ok(WeightAttr(weight_content.parse::<syn::Expr>()?))
384	}
385}
353386
354struct Method {387struct Method {
355	name: Ident,388	name: Ident,
362	has_normal_args: bool,395	has_normal_args: bool,
363	mutability: Mutability,396	mutability: Mutability,
364	result: Type,397	result: Type,
398	weight: Option<Expr>,
365	docs: Vec<String>,399	docs: Vec<String>,
366}400}
367impl Method {401impl Method {
370			rename_selector: None,404			rename_selector: None,
371		};405		};
372		let mut docs = Vec::new();406		let mut docs = Vec::new();
407		let mut weight = None;
373		for attr in &value.attrs {408		for attr in &value.attrs {
374			let ident = parse_ident_from_path(&attr.path, false)?;409			let ident = parse_ident_from_path(&attr.path, false)?;
375			if ident == "solidity" {410			if ident == "solidity" {
384					_ => unreachable!(),419					_ => unreachable!(),
385				};420				};
386				docs.push(value);421				docs.push(value);
387			}422			} else if ident == "weight" {
423				weight = Some(syn::parse2::<WeightAttr>(attr.to_token_stream())?.0);
424			}
388		}425		}
389		let ident = &value.sig.ident;426		let ident = &value.sig.ident;
390		let ident_str = ident.to_string();427		let ident_str = ident.to_string();
466			has_normal_args,503			has_normal_args,
467			mutability,504			mutability,
468			result: result.clone(),505			result: result.clone(),
506			weight,
469			docs,507			docs,
470		})508		})
471	}509	}
528		}566		}
529	}567	}
530568
531	fn expand_variant_call(&self) -> proc_macro2::TokenStream {569	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {
532		let pascal_name = &self.pascal_name;570		let pascal_name = &self.pascal_name;
533		let name = &self.name;571		let name = &self.name;
534572
555		let args = self.args.iter().map(|a| a.expand_call_arg());593		let args = self.args.iter().map(|a| a.expand_call_arg());
556594
557		quote! {595		quote! {
558			InternalCall::#pascal_name #matcher => {596			#call_name::#pascal_name #matcher => {
559				let result = #receiver #name(597				let result = #receiver #name(
560					#(598					#(
561						#args,599						#args,
562					)*600					)*
563				)?;601				)?;
564				(&result).abi_write(&mut writer);602				(&result).into_result()
565			}603			}
566		}604		}
567	}605	}
606
607	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {
608		let pascal_name = &self.pascal_name;
609		if let Some(weight) = &self.weight {
610			let matcher = if self.has_normal_args {
611				let names = self
612					.args
613					.iter()
614					.filter(|a| !a.is_special())
615					.map(|a| &a.name);
616
617				quote! {{
618					#(
619						#names,
620					)*
621				}}
622			} else {
623				quote! {}
624			};
625			quote! {
626				Self::#pascal_name #matcher => (#weight).into()
627			}
628		} else {
629			let matcher = if self.has_normal_args {
630				quote! {{..}}
631			} else {
632				quote! {}
633			};
634			quote! {
635				Self::#pascal_name #matcher => ().into()
636			}
637		}
638	}
568639
569	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {640	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {
570		let camel_name = &self.camel_name;641		let camel_name = &self.camel_name;
600	}671	}
601}672}
673
674fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {
675	if gen.params.is_empty() {
676		return quote! {};
677	}
678	let params = gen.params.iter().map(|p| match p {
679		syn::GenericParam::Type(id) => {
680			let v = &id.ident;
681			quote! {#v}
682		}
683		syn::GenericParam::Lifetime(lt) => {
684			let v = &lt.lifetime;
685			quote! {#v}
686		}
687		syn::GenericParam::Const(c) => {
688			let i = &c.ident;
689			quote! {#i}
690		}
691	});
692	quote! { #(#params),* }
693}
694fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {
695	if gen.params.is_empty() {
696		return quote! {};
697	}
698	let list = generics_list(gen);
699	quote! { <#list> }
700}
701fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {
702	let list = generics_list(gen);
703	if gen.params.len() == 1 {
704		quote! {#list}
705	} else {
706		quote! { (#list) }
707	}
708}
602709
603pub struct SolidityInterface {710pub struct SolidityInterface {
604	generics: Generics,711	generics: Generics,
628		let solidity_name = self.info.name.to_string();735		let solidity_name = self.info.name.to_string();
629		let call_name = pascal_ident_to_call(&self.info.name);736		let call_name = pascal_ident_to_call(&self.info.name);
630		let generics = self.generics;737		let generics = self.generics;
738		let gen_ref = generics_reference(&generics);
739		let gen_data = generics_data(&generics);
631740
632		let call_sub = self741		let call_sub = self
633			.info742			.info
634			.inline_is743			.inline_is
635			.0744			.0
636			.iter()745			.iter()
637			.chain(self.info.is.0.iter())746			.chain(self.info.is.0.iter())
638			.map(Is::expand_call_def);747			.map(|c| Is::expand_call_def(c, &gen_ref));
639		let call_parse = self748		let call_parse = self
640			.info749			.info
641			.inline_is750			.inline_is
642			.0751			.0
643			.iter()752			.iter()
644			.chain(self.info.is.0.iter())753			.chain(self.info.is.0.iter())
645			.map(Is::expand_parse);754			.map(|is| Is::expand_parse(is, &gen_ref));
646		let call_variants = self755		let call_variants = self
647			.info756			.info
648			.inline_is757			.inline_is
649			.0758			.0
650			.iter()759			.iter()
651			.chain(self.info.is.0.iter())760			.chain(self.info.is.0.iter())
652			.map(Is::expand_variant_call);761			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));
762		let weight_variants = self
763			.info
764			.inline_is
765			.0
766			.iter()
767			.chain(self.info.is.0.iter())
768			.map(Is::expand_variant_weight);
653769
654		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);770		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);
655		let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);771		let supports_interface = self
772			.info
773			.is
774			.0
775			.iter()
776			.map(|is| Is::expand_supports_interface(is, &gen_ref));
656777
657		let calls = self.methods.iter().map(Method::expand_call_def);778		let calls = self.methods.iter().map(Method::expand_call_def);
658		let consts = self.methods.iter().map(Method::expand_const);779		let consts = self.methods.iter().map(Method::expand_const);
659		let interface_id = self.methods.iter().map(Method::expand_interface_id);780		let interface_id = self.methods.iter().map(Method::expand_interface_id);
660		let parsers = self.methods.iter().map(Method::expand_parse);781		let parsers = self.methods.iter().map(Method::expand_parse);
661		let call_variants_this = self.methods.iter().map(Method::expand_variant_call);782		let call_variants_this = self
783			.methods
784			.iter()
785			.map(|m| Method::expand_variant_call(m, &call_name));
786		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);
662		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);787		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);
663788
664		// TODO: Inline inline_is789		// TODO: Inline inline_is
676			.0801			.0
677			.iter()802			.iter()
678			.chain(self.info.inline_is.0.iter())803			.chain(self.info.inline_is.0.iter())
679			.map(Is::expand_generator);804			.map(|is| Is::expand_generator(is, &gen_ref));
680		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);805		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);
681806
682		// let methods = self.methods.iter().map(Method::solidity_def);807		// let methods = self.methods.iter().map(Method::solidity_def);
683808
684		quote! {809		quote! {
685			#[derive(Debug)]810			#[derive(Debug)]
686			pub enum #call_name {811			pub enum #call_name #gen_ref {
687				ERC165Call(::evm_coder::ERC165Call),812				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),
688				#(813				#(
689					#calls,814					#calls,
690				)*815				)*
691				#(816				#(
692					#call_sub,817					#call_sub,
693				)*818				)*
694			}819			}
695			impl #call_name {820			impl #gen_ref #call_name #gen_ref {
696				#(821				#(
697					#consts822					#consts
698				)*823				)*
699				pub const fn interface_id() -> u32 {824				pub fn interface_id() -> u32 {
700					let mut interface_id = 0;825					let mut interface_id = 0;
701					#(#interface_id)*826					#(#interface_id)*
702					#(#inline_interface_id)*827					#(#inline_interface_id)*
748					tc.collect(out);873					tc.collect(out);
749				}874				}
750			}875			}
751			impl ::evm_coder::Call for #call_name {876			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {
752				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {877				fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {
753					use ::evm_coder::abi::AbiRead;878					use ::evm_coder::abi::AbiRead;
754					match method_id {879					match method_id {
755						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(::evm_coder::ERC165Call::parse(method_id, reader)?.map(Self::ERC165Call)),880						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(
881							::evm_coder::ERC165Call::parse(method_id, reader)?
882							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))
883						),
756						#(884						#(
757							#parsers,885							#parsers,
764					return Ok(None);892					return Ok(None);
765				}893				}
766			}894			}
767			impl #generics ::evm_coder::Callable<#call_name> for #name {895			impl #generics ::evm_coder::Weighted for #call_name #gen_ref {
896				#[allow(unused_variables)]
897				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {
898					match self {
899						#(
900							#weight_variants,
901						)*
902						// TODO: It should be very cheap, but not free
903						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),
904						#(
905							#weight_variants_this,
906						)*
907					}
908				}
909			}
910			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name {
768				#[allow(unreachable_code)] // In case of no inner calls911				#[allow(unreachable_code)] // In case of no inner calls
769				fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {912				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {
770					use ::evm_coder::abi::AbiWrite;913					use ::evm_coder::abi::AbiWrite;
771					type InternalCall = #call_name;
772					match c.call {914					match c.call {
773						#(915						#(
774							#call_variants,916							#call_variants,
775						)*917						)*
776						InternalCall::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}) => {918						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {
777							let mut writer = ::evm_coder::abi::AbiWriter::default();919							let mut writer = ::evm_coder::abi::AbiWriter::default();
778							writer.bool(&InternalCall::supports_interface(interface_id));920							writer.bool(&<#call_name #gen_ref>::supports_interface(interface_id));
779							return Ok(writer);921							return Ok(writer.into());
780						}922						}
781						_ => {},923						_ => {},
782					}924					}
787						)*929						)*
788						_ => unreachable!()930						_ => unreachable!()
789					}931					}
790					Ok(writer)
791				}932				}
792			}933			}
793		}934		}

12use primitive_types::{H160, U256};12use primitive_types::{H160, U256};
1313
14use crate::{execution::Error, types::string};14use crate::{
15	execution::{Error, ResultWithPostInfo, WithPostDispatchInfo},
16	types::string,
17};
15use crate::execution::Result;18use crate::execution::Result;
1619
244}247}
245248
246impl_abi_readable!(u32, uint32);249impl_abi_readable!(u32, uint32);
250impl_abi_readable!(u64, uint64);
247impl_abi_readable!(u128, uint128);251impl_abi_readable!(u128, uint128);
248impl_abi_readable!(U256, uint256);252impl_abi_readable!(U256, uint256);
249impl_abi_readable!(H160, address);253impl_abi_readable!(H160, address);
306310
307pub trait AbiWrite {311pub trait AbiWrite {
308	fn abi_write(&self, writer: &mut AbiWriter);312	fn abi_write(&self, writer: &mut AbiWriter);
313	fn into_result(&self) -> ResultWithPostInfo<AbiWriter> {
314		let mut writer = AbiWriter::new();
315		self.abi_write(&mut writer);
316		Ok(writer.into())
317	}
309}318}
319
320impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {
321	// this particular AbiWrite implementation should be split to another trait,
322	// which only implements [`into_result`]
323	//
324	// But due to lack of specialization feature in stable Rust, we can't have
325	// blanket impl of this trait `for T where T: AbiWrite`, so here we abusing
326	// default trait methods for it
327	fn abi_write(&self, _writer: &mut AbiWriter) {
328		debug_assert!(false, "shouldn't be called, see comment")
329	}
330	fn into_result(&self) -> ResultWithPostInfo<AbiWriter> {
331		match self {
332			Ok(v) => Ok(WithPostDispatchInfo {
333				post_info: v.post_info.clone(),
334				data: {
335					let mut out = AbiWriter::new();
336					v.data.abi_write(&mut out);
337					out
338				},
339			}),
340			Err(e) => Err(e.clone()),
341		}
342	}
343}
310344
311macro_rules! impl_abi_writeable {345macro_rules! impl_abi_writeable {
312	($ty:ty, $method:ident) => {346	($ty:ty, $method:ident) => {

4#[cfg(feature = "std")]4#[cfg(feature = "std")]
5use std::string::{String, ToString};5use std::string::{String, ToString};
6
7use crate::Weight;
68
7#[derive(Debug)]9#[derive(Debug, Clone)]
8pub enum Error {10pub enum Error {
9	Revert(String),11	Revert(String),
10	Fatal(ExitFatal),12	Fatal(ExitFatal),
2224
23pub type Result<T> = core::result::Result<T, Error>;25pub type Result<T> = core::result::Result<T, Error>;
26
27pub struct DispatchInfo {
28	pub weight: Weight,
29}
30
31impl From<Weight> for DispatchInfo {
32	fn from(weight: Weight) -> Self {
33		Self { weight }
34	}
35}
36impl From<()> for DispatchInfo {
37	fn from(_: ()) -> Self {
38		Self { weight: 0 }
39	}
40}
41
42#[derive(Default, Clone)]
43pub struct PostDispatchInfo {
44	actual_weight: Option<Weight>,
45}
46
47impl PostDispatchInfo {
48	pub fn calc_unspent(&self, info: &DispatchInfo) -> Weight {
49		info.weight - self.calc_actual_weight(info)
50	}
51
52	pub fn calc_actual_weight(&self, info: &DispatchInfo) -> Weight {
53		if let Some(actual_weight) = self.actual_weight {
54			actual_weight.min(info.weight)
55		} else {
56			info.weight
57		}
58	}
59}
60
61#[derive(Clone)]
62pub struct WithPostDispatchInfo<T> {
63	pub data: T,
64	pub post_info: PostDispatchInfo,
65}
66
67impl<T> From<T> for WithPostDispatchInfo<T> {
68	fn from(data: T) -> Self {
69		Self {
70			data,
71			post_info: Default::default(),
72		}
73	}
74}
75
76pub type ResultWithPostInfo<T> =
77	core::result::Result<WithPostDispatchInfo<T>, WithPostDispatchInfo<Error>>;
2478

3extern crate alloc;3extern crate alloc;
44
5use abi::{AbiRead, AbiReader, AbiWriter};5use abi::{AbiRead, AbiReader, AbiWriter};
6pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, ToLog};6pub use evm_coder_macros::{event_topic, fn_selector, solidity_interface, solidity, weight, ToLog};
7pub mod abi;7pub mod abi;
8pub mod events;8pub mod events;
9pub use events::ToLog;9pub use events::ToLog;
10use execution::DispatchInfo;
10pub mod execution;11pub mod execution;
11pub mod solidity;12pub mod solidity;
1213
57	fn parse(selector: u32, input: &mut AbiReader) -> execution::Result<Option<Self>>;58	fn parse(selector: u32, input: &mut AbiReader) -> execution::Result<Option<Self>>;
58}59}
60
61pub type Weight = u64;
62
63pub trait Weighted: Call {
64	fn weight(&self) -> DispatchInfo;
65}
5966
60pub trait Callable<C: Call> {67pub trait Callable<C: Call> {
61	fn call(&mut self, call: types::Msg<C>) -> execution::Result<AbiWriter>;68	fn call(&mut self, call: types::Msg<C>) -> execution::ResultWithPostInfo<AbiWriter>;
62}69}
6370
64/// Implementation is implicitly provided for all interfaces71/// Implementation is implicitly provided for all interfaces
84	}91	}
85}92}
8693
94/// Generate "tests", which will generate solidity code on execution and print it to stdout
95/// Script at .maintain/scripts/generate_api.sh can split this output from test runtime
96///
97/// This macro receives type usage as second argument, but you can use anything as generics,
98/// because no bounds are implied
87#[macro_export]99#[macro_export]
88macro_rules! generate_stubgen {100macro_rules! generate_stubgen {
89	($name:ident, $decl:ident, $is_impl:literal) => {101	($name:ident, $decl:ty, $is_impl:literal) => {
90		#[test]102		#[test]
91		#[ignore]103		#[ignore]
92		fn $name() {104		fn $name() {
93			use evm_coder::solidity::TypeCollector;105			use evm_coder::solidity::TypeCollector;
94			let mut out = TypeCollector::new();106			let mut out = TypeCollector::new();
95			$decl::generate_solidity_interface(&mut out, $is_impl);107			<$decl>::generate_solidity_interface(&mut out, $is_impl);
96			println!("=== SNIP START ===");108			println!("=== SNIP START ===");
97			println!("// SPDX-License-Identifier: OTHER");109			println!("// SPDX-License-Identifier: OTHER");
98			println!("// This code is automatically generated");110			println!("// This code is automatically generated");

268jsonrpc-core = '18.0.0'268jsonrpc-core = '18.0.0'
269jsonrpc-pubsub = "18.0.0"269jsonrpc-pubsub = "18.0.0"
270270
271fc-rpc-core = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }271fc-rpc-core = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
272fc-consensus = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }272fc-consensus = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
273fc-mapping-sync = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }273fc-mapping-sync = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
274fc-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }274fc-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
275fc-db = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }275fc-db = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
276fp-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }276fp-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
277pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }277pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
278278
279nft-rpc = { path = "../rpc" }279nft-rpc = { path = "../rpc" }
280280

41substrate-frame-rpc-system = { git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }41substrate-frame-rpc-system = { git = 'https://github.com/paritytech/substrate.git', branch = 'polkadot-v0.9.12' }
42tokio = { version = "0.2.25", features = ["macros", "sync"] }42tokio = { version = "0.2.25", features = ["macros", "sync"] }
4343
44pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }44pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
45fc-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }45fc-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
46fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }46fp-rpc = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
47fc-rpc-core = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }47fc-rpc-core = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
48fc-db = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }48fc-db = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }49fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
5050
51pallet-nft = { path = "../../pallets/nft" }51pallet-nft = { path = "../../pallets/nft" }
52uc-rpc = { path = "../../client/rpc" }52uc-rpc = { path = "../../client/rpc" }

19pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }19pallet-evm-coder-substrate = { default-features = false, path = '../../pallets/evm-coder-substrate' }
20evm-coder = { default-features = false, path = '../../crates/evm-coder' }20evm-coder = { default-features = false, path = '../../crates/evm-coder' }
2121
22pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12" }22pallet-evm = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.12-weights" }
23serde = { version = "1.0.130", default-features = false }23serde = { version = "1.0.130", default-features = false }
24scale-info = { version = "1.0.0", default-features = false, features = [24scale-info = { version = "1.0.0", default-features = false, features = [
25    "derive",25    "derive",

1#![cfg_attr(not(feature = "std"), no_std)]1#![cfg_attr(not(feature = "std"), no_std)]
22
3use core::ops::{Deref, DerefMut};3use core::ops::{Deref, DerefMut};
4use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
4use sp_std::vec::Vec;5use sp_std::vec::Vec;
5use account::CrossAccountId;6use account::CrossAccountId;
6use frame_support::{7use frame_support::{
7	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo},8	dispatch::{DispatchErrorWithPostInfo, DispatchResultWithPostInfo},
8	ensure, fail,9	ensure, fail,
9	traits::{Imbalance, Get, Currency},10	traits::{Imbalance, Get, Currency},
10};11};
12use pallet_evm::GasWeightMapping;
11use nft_data_structs::{13use nft_data_structs::{
12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,14	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,
13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,15	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
27pub struct CollectionHandle<T: Config> {29pub struct CollectionHandle<T: Config> {
28	pub id: CollectionId,30	pub id: CollectionId,
29	collection: Collection<T>,31	collection: Collection<T>,
30	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,32	pub recorder: SubstrateRecorder<T>,
31}33}
34impl<T: Config> WithRecorder<T> for CollectionHandle<T> {
35	fn recorder(&self) -> &SubstrateRecorder<T> {
36		&self.recorder
37	}
38	fn into_recorder(self) -> SubstrateRecorder<T> {
39		self.recorder
40	}
41}
32impl<T: Config> CollectionHandle<T> {42impl<T: Config> CollectionHandle<T> {
33	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {43	pub fn new_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {
34		<CollectionById<T>>::get(id).map(|collection| Self {44		<CollectionById<T>>::get(id).map(|collection| Self {
35			id,45			id,
36			collection,46			collection,
37			recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(47			recorder: SubstrateRecorder::new(eth::collection_id_to_address(id), gas_limit),
38				eth::collection_id_to_address(id),
39				gas_limit,
40			),
46	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {53	pub fn try_get(id: CollectionId) -> Result<Self, DispatchError> {
47		Ok(Self::new(id).ok_or_else(|| <Error<T>>::CollectionNotFound)?)54		Ok(Self::new(id).ok_or_else(|| <Error<T>>::CollectionNotFound)?)
48	}55	}
49	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {56	pub fn log(&self, log: impl evm_coder::ToLog) {
50		self.recorder.log_sub(log)57		self.recorder.log(log)
51	}58	}
52	pub fn log_infallible(&self, log: impl evm_coder::ToLog) {59	pub fn consume_store_reads(&self, reads: u64) -> evm_coder::execution::Result<()> {
53		self.recorder.log_infallible(log)
54	}
55	#[allow(dead_code)]
56	fn consume_gas(&self, gas: u64) -> DispatchResult {
57		self.recorder.consume_gas_sub(gas)
58	}
59	pub fn consume_sload(&self) -> DispatchResult {
60		self.recorder.consume_sload_sub()60		self.recorder
61			.consume_gas(T::GasWeightMapping::weight_to_gas(
62				<T as frame_system::Config>::DbWeight::get()
63					.read
64					.saturating_mul(reads),
65			))
61	}66	}
62	pub fn consume_sstores(&self, amount: usize) -> DispatchResult {67	pub fn consume_store_writes(&self, writes: u64) -> evm_coder::execution::Result<()> {
63		self.recorder.consume_sstores_sub(amount)
64	}
65	pub fn consume_sstore(&self) -> DispatchResult {
66		self.recorder.consume_sstore_sub()
67	}
68	pub fn consume_log(&self, topics: usize, data: usize) -> DispatchResult {
69		self.recorder.consume_log_sub(topics, data)68		self.recorder
69			.consume_gas(T::GasWeightMapping::weight_to_gas(
70				<T as frame_system::Config>::DbWeight::get()
71					.write
72					.saturating_mul(writes),
73			))
70	}74	}
71	pub fn submit_logs(self) -> DispatchResult {75	pub fn submit_logs(self) {
72		self.recorder.submit_logs()76		self.recorder.submit_logs()
73	}77	}
74	pub fn save(self) -> DispatchResult {78	pub fn save(self) -> DispatchResult {
75		self.recorder.submit_logs()?;79		self.recorder.submit_logs();
76		<CollectionById<T>>::insert(self.id, self.collection);80		<CollectionById<T>>::insert(self.id, self.collection);
77		Ok(())81		Ok(())
78	}82	}
96		ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);100		ensure!(*subject.as_sub() == self.owner, <Error<T>>::NoPermission);
97		Ok(())101		Ok(())
98	}102	}
99	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> Result<bool, DispatchError> {103	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> bool {
100		self.consume_sload()?;
101
102		Ok(*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject)))104		*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject))
103	}105	}
104	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {106	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {
105		ensure!(self.is_owner_or_admin(subject)?, <Error<T>>::NoPermission);107		ensure!(self.is_owner_or_admin(subject), <Error<T>>::NoPermission);
106		Ok(())108		Ok(())
107	}109	}
108	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {110	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> bool {
109		Ok(self.limits.owner_can_transfer() && self.is_owner_or_admin(user)?)111		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)
110	}112	}
111	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {113	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> bool {
112		Ok(self.limits.owner_can_transfer() && self.is_owner_or_admin(user)?)114		self.limits.owner_can_transfer() && self.is_owner_or_admin(user)
113	}115	}
114	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {116	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {
115		self.consume_sload()?;
116
117		ensure!(117		ensure!(
118			<Allowlist<T>>::get((self.id, user)),118			<Allowlist<T>>::get((self.id, user)),