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

1use quote::quote;1use quote::quote;
2
3use super::extract_docs;
24
3pub fn impl_solidity_option<'a>(5pub fn impl_solidity_option<'a>(
6	docs: Vec<String>,
4	name: &proc_macro2::Ident,7	name: &proc_macro2::Ident,
5	enum_options: impl Iterator<Item = &'a syn::Ident>,8	enum_options: impl Iterator<Item = &'a syn::Variant> + Clone,
6) -> proc_macro2::TokenStream {9) -> proc_macro2::TokenStream {
7	let enum_options = enum_options.map(|opt| {10	let variant_names = enum_options.clone().map(|opt| {
11		let opt = &opt.ident;
8		let s = name.to_string() + "." + opt.to_string().as_str();12		let s = name.to_string() + "." + opt.to_string().as_str();
9		let as_string = proc_macro2::Literal::string(s.as_str());13		let as_string = proc_macro2::Literal::string(s.as_str());
10		quote!(#name::#opt => #as_string,)14		quote!(#name::#opt => #as_string,)
11	});15	});
16	let solidity_name = name.to_string();
17
18	let solidity_fields = enum_options.map(|v| {
19		let docs = extract_docs(&v.attrs).expect("TODO: handle bad docs");
20		let name = v.ident.to_string();
21		quote! {
22			SolidityEnumVariant {
23				docs: &[#(#docs),*],
24				name: #name,
25			}
26		}
27	});
28
12	quote!(29	quote!(
13		#[cfg(feature = "stubgen")]30		#[cfg(feature = "stubgen")]
14		impl ::evm_coder::solidity::SolidityEnum for #name {31		impl ::evm_coder::solidity::SolidityEnumTy for #name {
32			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
33				use evm_coder::solidity::*;
34				use core::fmt::Write;
35				let interface = SolidityEnum {
36					docs: &[#(#docs),*],
37					name: #solidity_name,
38					fields: &[#(
39						#solidity_fields,
40					)*],
41				};
42				let mut out = String::new();
43				let _ = interface.format(&mut out, tc);
44				tc.collect(out);
45				#solidity_name.to_string()
46			}
15			fn solidity_option(&self) -> &str {47			fn solidity_option(&self) -> &str {
16				match self {48				match self {
17					#(#enum_options)*49					#(#variant_names)*
18				}50				}
19			}51			}
20		}52		}
2355
24pub fn impl_enum_from_u8<'a>(56pub fn impl_enum_from_u8<'a>(
25	name: &proc_macro2::Ident,57	name: &proc_macro2::Ident,
26	enum_options: impl Iterator<Item = &'a syn::Ident>,58	enum_options: impl Iterator<Item = &'a syn::Variant>,
27) -> proc_macro2::TokenStream {59) -> proc_macro2::TokenStream {
28	let error_str = format!("Value not convertible into enum \"{name}\"");60	let error_str = format!("Value not convertible into enum \"{name}\"");
29	let error_str = proc_macro2::Literal::string(&error_str);61	let error_str = proc_macro2::Literal::string(&error_str);
30	let enum_options = enum_options.enumerate().map(|(i, opt)| {62	let enum_options = enum_options.enumerate().map(|(i, opt)| {
63		let opt = &opt.ident;
31		let n = proc_macro2::Literal::u8_suffixed(i as u8);64		let n = proc_macro2::Literal::u8_suffixed(i as u8);
32		quote! {#n => Ok(#name::#opt),}65		quote! {#n => Ok(#name::#opt),}
33	});66	});
93				writer: &mut impl ::core::fmt::Write,126				writer: &mut impl ::core::fmt::Write,
94				tc: &::evm_coder::solidity::TypeCollector,127				tc: &::evm_coder::solidity::TypeCollector,
95			) -> ::core::fmt::Result {128			) -> ::core::fmt::Result {
96				write!(writer, "{}", tc.collect_struct::<Self>())129				write!(writer, "{}", tc.collect_enum::<Self>())
97			}130			}
98131
99			fn is_simple() -> bool {132			fn is_simple() -> bool {
104				writer: &mut impl ::core::fmt::Write,137				writer: &mut impl ::core::fmt::Write,
105				tc: &::evm_coder::solidity::TypeCollector,138				tc: &::evm_coder::solidity::TypeCollector,
106			) -> ::core::fmt::Result {139			) -> ::core::fmt::Result {
107				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))140				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnumTy>::solidity_option(&<#name>::default()))
108			}141			}
109		}142		}
110	)143	)
111}144}
112
113pub fn impl_enum_solidity_struct_collect<'a>(
114	name: &syn::Ident,
115	enum_options: impl Iterator<Item = &'a syn::Ident>,
116	option_count: usize,
117	enum_options_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>>,
118	docs: &[proc_macro2::TokenStream],
119) -> proc_macro2::TokenStream {
120	let string_name = name.to_string();
121	let enum_options = enum_options
122		.zip(enum_options_docs)
123		.enumerate()
124		.map(|(i, (opt, doc))| {
125			let opt = proc_macro2::Literal::string(opt.to_string().as_str());
126			let doc = doc.expect("Doc parsing error");
127			let comma = if i != option_count - 1 { "," } else { "" };
128			quote! {
129				#(#doc)*
130				writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");
131			}
132		});
133
134	quote!(
135		#[cfg(feature = "stubgen")]
136		impl ::evm_coder::solidity::StructCollect for #name {
137			fn name() -> String {
138				#string_name.into()
139			}
140
141			fn declaration() -> String {
142				use std::fmt::Write;
143
144				let mut str = String::new();
145				#(#docs)*
146				writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();
147				#(#enum_options)*
148				writeln!(str, "}}").unwrap();
149				str
150			}
151		}
152	)
153}
154145
155pub fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {146pub fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {
156	let mut count = 0;147	let mut count = 0;

1use super::extract_docs;1use super::extract_docs;
2use quote::quote;2use quote::quote;
3use syn::Field;
34
4pub fn tuple_type<'a>(5pub fn tuple_type<'a>(
5	field_types: impl Iterator<Item = &'a syn::Type> + Clone,6	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
87	&field.ty88	&field.ty
88}89}
89
90pub fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {
91	extract_docs(&field.attrs, true)
92}
9390
94pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {91pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {
95	quote! {92	quote! {
147144
148pub fn impl_struct_solidity_type<'a>(145pub fn impl_struct_solidity_type<'a>(
149	name: &syn::Ident,146	name: &syn::Ident,
147	docs: Vec<String>,
150	field_types: impl Iterator<Item = &'a syn::Type> + Clone,148	fields: impl Iterator<Item = &'a Field> + Clone,
151	params_count: usize,
152) -> proc_macro2::TokenStream {149) -> proc_macro2::TokenStream {
150	let solidity_name = name.to_string();
153	let len = proc_macro2::Literal::usize_suffixed(params_count);151	let solidity_fields = fields.enumerate().map(|(i, f)| {
152		let name = f
153			.ident
154			.as_ref()
155			.map(|i| i.to_string())
156			.unwrap_or_else(|| format!("field_{i}"));
157		let ty = &f.ty;
158		let docs = extract_docs(&f.attrs).expect("TODO: handle bad docs");
159		quote! {
160			SolidityStructField::<#ty> {
161				docs: &[#(#docs),*],
162				name: #name,
163				ty: ::core::marker::PhantomData,
164			}
165		}
166	});
154	quote! {167	quote! {
155		#[cfg(feature = "stubgen")]168		#[cfg(feature = "stubgen")]
156		impl ::evm_coder::solidity::SolidityType for #name {169		impl ::evm_coder::solidity::SolidityStructTy for #name {
170			/// Generate solidity definitions for methods described in this struct
157			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {171			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
158				let mut collected =
159					Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());172				use evm_coder::solidity::*;
173				use core::fmt::Write;
174				let interface = SolidityStruct {
175					docs: &[#(#docs),*],
160				#({176					name: #solidity_name,
177					fields: (#(
178						#solidity_fields,
179					)*),
180				};
161					let mut out = String::new();181				let mut out = String::new();
162					<#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)182				let _ = interface.format(&mut out, tc);
163						.expect("no fmt error");
164					collected.push(out);183				tc.collect(out);
165				})*
166				collected
167			}
168
169			fn len() -> usize {
170				#len184				#solidity_name.to_string()
171			}185			}
172		}186		}
173	}187	}
174}188}
216	}230	}
217}231}
218
219pub fn impl_struct_solidity_struct_collect<'a>(
220	name: &syn::Ident,
221	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,
222	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
223	field_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>> + Clone,
224	docs: &[proc_macro2::TokenStream],
225) -> syn::Result<proc_macro2::TokenStream> {
226	let string_name = name.to_string();
227	let name_type = field_names
228		.into_iter()
229		.zip(field_types)
230		.zip(field_docs)
231		.map(|((name, ty), doc)| {
232			let field_docs = doc.expect("Doc parse error");
233			let name = format!("{}", name);
234			quote!(
235				#(#field_docs)*
236				write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();
237				writeln!(str, "{};", #name).unwrap();
238			)
239		});
240
241	Ok(quote! {
242		#[cfg(feature = "stubgen")]
243		impl ::evm_coder::solidity::StructCollect for #name {
244			fn name() -> String {
245				#string_name.into()
246			}
247
248			fn declaration() -> String {
249				use std::fmt::Write;
250
251				let mut str = String::new();
252				#(#docs)*
253				writeln!(str, "struct {} {{", Self::name()).unwrap();
254				#(#name_type)*
255				writeln!(str, "}}").unwrap();
256				str
257			}
258		}
259	})
260}
261232

19	ast: &syn::DeriveInput,19	ast: &syn::DeriveInput,
20) -> syn::Result<proc_macro2::TokenStream> {20) -> syn::Result<proc_macro2::TokenStream> {
21	let name = &ast.ident;21	let name = &ast.ident;
22	let docs = extract_docs(&ast.attrs, false)?;22	let docs = extract_docs(&ast.attrs)?;
23	let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {23	let (is_named_fields, field_names, field_types, params_count) = match ds.fields {
24		syn::Fields::Named(ref fields) => Ok((24		syn::Fields::Named(ref fields) => Ok((
25			true,25			true,
26			fields.named.iter().enumerate().map(map_field_to_name),26			fields.named.iter().enumerate().map(map_field_to_name),
27			fields.named.iter().map(map_field_to_type),27			fields.named.iter().map(map_field_to_type),
28			fields.named.iter().map(map_field_to_doc),
29			fields.named.len(),28			fields.named.len(),
30		)),29		)),
31		syn::Fields::Unnamed(ref fields) => Ok((30		syn::Fields::Unnamed(ref fields) => Ok((
32			false,31			false,
33			fields.unnamed.iter().enumerate().map(map_field_to_name),32			fields.unnamed.iter().enumerate().map(map_field_to_name),
34			fields.unnamed.iter().map(map_field_to_type),33			fields.unnamed.iter().map(map_field_to_type),
35			fields.unnamed.iter().map(map_field_to_doc),
36			fields.unnamed.len(),34			fields.unnamed.len(),
37		)),35		)),
38		syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),36		syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),
52	let abi_type = impl_struct_abi_type(name, tuple_type.clone());50	let abi_type = impl_struct_abi_type(name, tuple_type.clone());
53	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);51	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);
54	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);52	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);
55	let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);53	let solidity_type = impl_struct_solidity_type(name, docs, ds.fields.iter());
56	let solidity_type_name =54	let solidity_type_name =
57		impl_struct_solidity_type_name(name, field_types.clone(), params_count);55		impl_struct_solidity_type_name(name, field_types.clone(), params_count);
58	let solidity_struct_collect =
59		impl_struct_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;
6056
61	Ok(quote! {57	Ok(quote! {
62		#can_be_plcaed_in_vec58		#can_be_plcaed_in_vec
65		#abi_write61		#abi_write
66		#solidity_type62		#solidity_type
67		#solidity_type_name63		#solidity_type_name
68		#solidity_struct_collect
69	})64	})
70}65}
7166
75) -> syn::Result<proc_macro2::TokenStream> {70) -> syn::Result<proc_macro2::TokenStream> {
76	let name = &ast.ident;71	let name = &ast.ident;
77	check_repr_u8(name, &ast.attrs)?;72	check_repr_u8(name, &ast.attrs)?;
78	let docs = extract_docs(&ast.attrs, false)?;73	let docs = extract_docs(&ast.attrs)?;
79	let option_count = check_and_count_options(de)?;
80	let enum_options = de.variants.iter().map(|v| &v.ident);74	let enum_options = de.variants.iter();
81	let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, true));
8275
83	let from = impl_enum_from_u8(name, enum_options.clone());76	let from = impl_enum_from_u8(name, enum_options.clone());
84	let solidity_option = impl_solidity_option(name, enum_options.clone());77	let solidity_option = impl_solidity_option(docs, name, enum_options.clone());
85	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);78	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
86	let abi_type = impl_enum_abi_type(name);79	let abi_type = impl_enum_abi_type(name);
87	let abi_read = impl_enum_abi_read(name);80	let abi_read = impl_enum_abi_read(name);
88	let abi_write = impl_enum_abi_write(name);81	let abi_write = impl_enum_abi_write(name);
89	let solidity_type_name = impl_enum_solidity_type_name(name);82	let solidity_type_name = impl_enum_solidity_type_name(name);
90	let solidity_struct_collect = impl_enum_solidity_struct_collect(
91		name,
92		enum_options,
93		option_count,
94		enum_options_docs,
95		&docs,
96	);
9783
98	Ok(quote! {84	Ok(quote! {
99		#from85		#from
103		#abi_read89		#abi_read
104		#abi_write90		#abi_write
105		#solidity_type_name91		#solidity_type_name
106		#solidity_struct_collect
107	})92	})
108}93}
10994
110fn extract_docs(95fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {
111	attrs: &[syn::Attribute],
112	is_field_doc: bool,
113) -> syn::Result<Vec<proc_macro2::TokenStream>> {
114	attrs96	attrs
115		.iter()97		.iter()
116		.filter_map(|attr| {98		.filter_map(|attr| {
131			}113			}
132			None114			None
133		})115		})
134		.enumerate()
135		.map(|(i, doc)| {
136			let doc = doc?;
137			let doc = doc.trim();
138			let dev = if i == 0 { " @dev" } else { "" };
139			let tab = if is_field_doc { "\t" } else { "" };
140			Ok(quote! {
141				writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();
142			})
143		})
144		.collect()116		.collect()
145}117}
146118

135	}135	}
136}136}
137
138impl sealed::CanBePlacedInVec for Property {}
139
140impl AbiType for Property {
141	const SIGNATURE: SignatureUnit = make_signature!(new fixed("(string,bytes)"));
142
143	fn is_dynamic() -> bool {
144		string::is_dynamic() || bytes::is_dynamic()
145	}
146
147	fn size() -> usize {
148		<string as AbiType>::size() + <bytes as AbiType>::size()
149	}
150}
151
152impl AbiRead for Property {
153	fn abi_read(reader: &mut AbiReader) -> Result<Property> {
154		let size = if !Property::is_dynamic() {
155			Some(<Property as AbiType>::size())
156		} else {
157			None
158		};
159		let mut subresult = reader.subresult(size)?;
160		let key = <string>::abi_read(&mut subresult)?;
161		let value = <bytes>::abi_read(&mut subresult)?;
162
163		Ok(Property { key, value })
164	}
165}
166
167impl AbiWrite for Property {
168	fn abi_write(&self, writer: &mut AbiWriter) {
169		(&self.key, &self.value).abi_write(writer);
170	}
171}
172137
173impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {138impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {
174	fn abi_write(&self, writer: &mut AbiWriter) {139	fn abi_write(&self, writer: &mut AbiWriter) {

197		}197		}
198	}198	}
199
200	#[derive(Debug, Default)]
201	pub struct Property {
202		pub key: string,
203		pub value: bytes,
204	}
205}199}
206200
207/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro201/// Parseable EVM call, this trait should be implemented with [`solidity_interface`] macro

1use super::{TypeCollector, SolidityTypeName, SolidityType, StructCollect};1use super::{TypeCollector, SolidityTypeName, SolidityTupleTy};
2use crate::{sealed, types::*};2use crate::{sealed, types::*};
3use core::fmt;3use core::fmt;
4use primitive_types::{U256, H160};4use primitive_types::{U256, H160};
18				}18				}
19            }19            }
20
21			impl StructCollect for $ty {
22				fn name() -> String {
23					$name.to_string()
24				}
25
26				fn declaration() -> String {
27					String::default()
28				}
29			}
30        )*20        )*
31    };21    };
32}22}
8171
82macro_rules! impl_tuples {72macro_rules! impl_tuples {
83	($($ident:ident)+) => {73	($($ident:ident)+) => {
84		impl<$($ident: SolidityTypeName + 'static),+> SolidityType for ($($ident,)+) {74		impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleTy for ($($ident,)+) {
85			fn names(tc: &TypeCollector) -> Vec<string> {75			fn fields(tc: &TypeCollector) -> Vec<string> {
86				let mut collected = Vec::with_capacity(Self::len());76				let mut collected = Vec::with_capacity(Self::len());
87				$({77				$({
88					let mut out = string::new();78					let mut out = string::new();
132impl_tuples! {A B C D E F G H I}122impl_tuples! {A B C D E F G H I}
133impl_tuples! {A B C D E F G H I J}123impl_tuples! {A B C D E F G H I J}
134
135impl StructCollect for Property {
136	fn name() -> String {
137		"Property".into()
138	}
139
140	fn declaration() -> String {
141		use std::fmt::Write;
142
143		let mut str = String::new();
144		writeln!(str, "/// @dev Property struct").unwrap();
145		writeln!(str, "struct {} {{", Self::name()).unwrap();
146		writeln!(str, "\tstring key;").unwrap();
147		writeln!(str, "\tbytes value;").unwrap();
148		writeln!(str, "}}").unwrap();
149		str
150	}
151}
152
153impl SolidityTypeName for Property {
154	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
155		write!(writer, "{}", tc.collect_struct::<Self>())
156	}
157
158	fn is_simple() -> bool {
159		false
160	}
161
162	fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
163		write!(writer, "{}(", tc.collect_struct::<Self>())?;
164		address::solidity_default(writer, tc)?;
165		write!(writer, ",")?;
166		uint256::solidity_default(writer, tc)?;
167		write!(writer, ")")
168	}
169}
170
171impl SolidityType for Property {
172	fn names(tc: &TypeCollector) -> Vec<string> {
173		let mut collected = Vec::with_capacity(Self::len());
174		{
175			let mut out = string::new();
176			string::solidity_name(&mut out, tc).expect("no fmt error");
177			collected.push(out);
178		}
179		{
180			let mut out = string::new();
181			bytes::solidity_name(&mut out, tc).expect("no fmt error");
182			collected.push(out);
183		}
184		collected
185	}
186
187	fn len() -> usize {
188		2
189	}
190}
191124

44	/// id ordering is required to perform topo-sort on the resulting data44	/// id ordering is required to perform topo-sort on the resulting data
45	structs: RefCell<BTreeMap<string, usize>>,45	structs: RefCell<BTreeMap<string, usize>>,
46	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,46	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
47	// generic: RefCell<BTreeMap<string, usize>>,
47	id: Cell<usize>,48	id: Cell<usize>,
48}49}
49impl TypeCollector {50impl TypeCollector {
59		self.id.set(v + 1);60		self.id.set(v + 1);
60		v61		v
61	}62	}
63	/// Collect typle, deduplicating it by type, and returning generated name
62	pub fn collect_tuple<T: SolidityType>(&self) -> String {64	pub fn collect_tuple<T: SolidityTupleTy>(&self) -> String {
63		let names = T::names(self);65		let names = T::fields(self);
64		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {66		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {
65			return format!("Tuple{}", id);67			return format!("Tuple{}", id);
66		}68		}
76		self.anonymous.borrow_mut().insert(names, id);78		self.anonymous.borrow_mut().insert(names, id);
77		format!("Tuple{}", id)79		format!("Tuple{}", id)
78	}80	}
79	pub fn collect_struct<T: StructCollect>(&self) -> String {81	pub fn collect_struct<T: SolidityStructTy>(&self) -> String {
80		self.collect(<T as StructCollect>::declaration());
81		<T as StructCollect>::name()82		T::generate_solidity_interface(self)
82	}83	}
84	pub fn collect_enum<T: SolidityEnumTy>(&self) -> String {
85		T::generate_solidity_interface(self)
86	}
83	pub fn finish(self) -> Vec<string> {87	pub fn finish(self) -> Vec<string> {
84		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();88		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
85		data.sort_by_key(|(_, id)| Reverse(*id));89		data.sort_by_key(|(_, id)| Reverse(*id));
420	}424	}
421}425}
426
427#[impl_for_tuples(0, 48)]
428impl SolidityItems for Tuple {
429	for_tuples!( where #( Tuple: SolidityItems ),* );
430
431	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
432		for_tuples!( #(
433            Tuple.solidity_name(writer, tc)?;
434        )* );
435		Ok(())
436	}
437}
438
439pub struct SolidityStructField<T> {
440	pub docs: &'static [&'static str],
441	pub name: &'static str,
442	pub ty: PhantomData<*const T>,
443}
444
445impl<T> SolidityItems for SolidityStructField<T>
446where
447	T: SolidityTypeName,
448{
449	fn solidity_name(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
450		for doc in self.docs {
451			writeln!(out, "///{}", doc)?;
452		}
453		write!(out, "\t")?;
454		T::solidity_name(out, tc)?;
455		writeln!(out, " {};", self.name)?;
456		Ok(())
457	}
458}
459pub struct SolidityStruct<F> {
460	pub docs: &'static [&'static str],
461	// pub generics:
462	pub name: &'static str,
463	pub fields: F,
464}
465impl<F> SolidityStruct<F>
466where
467	F: SolidityItems,
468{
469	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
470		for doc in self.docs {
471			writeln!(out, "///{}", doc)?;
472		}
473		writeln!(out, "struct {} {{", self.name)?;
474		self.fields.solidity_name(out, tc)?;
475		writeln!(out, "}}")?;
476		Ok(())
477	}
478}
479
480pub struct SolidityEnumVariant {
481	pub docs: &'static [&'static str],
482	pub name: &'static str,
483}
484impl SolidityItems for SolidityEnumVariant {
485	fn solidity_name(&self, out: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
486		for doc in self.docs {
487			writeln!(out, "///{}", doc)?;
488		}
489		write!(out, "\t{}", self.name)?;
490		Ok(())
491	}
492}
493pub struct SolidityEnum {
494	pub docs: &'static [&'static str],
495	pub name: &'static str,
496	pub fields: &'static [SolidityEnumVariant],
497}
498impl SolidityEnum {
499	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
500		for doc in self.docs {
501			writeln!(out, "///{}", doc)?;
502		}
503		write!(out, "enum {} {{", self.name)?;
504		for (i, field) in self.fields.iter().enumerate() {
505			if i != 0 {
506				write!(out, ",")?;
507			}
508			writeln!(out)?;
509			field.solidity_name(out, tc)?;
510		}
511		writeln!(out)?;
512		writeln!(out, "}}")?;
513		Ok(())
514	}
515}
422516

1use super::TypeCollector;1use super::TypeCollector;
2use core::fmt;2use core::fmt;
3
4pub trait StructCollect: 'static {
5	/// Structure name.
6	fn name() -> String;
7	/// Structure declaration.
8	fn declaration() -> String;
9}
10
11pub trait SolidityEnum: 'static {
12	fn solidity_option(&self) -> &str;
13}
143
15pub trait SolidityTypeName: 'static {4pub trait SolidityTypeName: 'static {
16	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;5	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
23	}12	}
24}13}
2514
26pub trait SolidityType {15pub trait SolidityTupleTy: 'static {
27	fn names(tc: &TypeCollector) -> Vec<String>;16	fn fields(tc: &TypeCollector) -> Vec<String>;
28	fn len() -> usize;17	fn len() -> usize;
29}18}
19pub trait SolidityStructTy: 'static {
20	fn generate_solidity_interface(tc: &TypeCollector) -> String;
21}
22pub trait SolidityEnumTy: 'static {
23	fn generate_solidity_interface(tc: &TypeCollector) -> String;
24	fn solidity_option(&self) -> &str;
25}
3026
31pub trait SolidityArguments {27pub trait SolidityArguments {
32	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;28	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
47	) -> fmt::Result;43	) -> fmt::Result;
48}44}
45
46pub trait SolidityItems {
47	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
48	// For PhantomData fields
49	// fn is_void()
50}
4951