1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4 let name = &ast.ident;5 let (is_named_fields, field_names, field_types, params_count) = match &ast.data {6 syn::Data::Struct(ds) => match ds.fields {7 syn::Fields::Named(ref fields) => Ok((8 true,9 fields.named.iter().enumerate().map(map_field_to_name),10 fields.named.iter().map(map_field_to_type),11 fields.named.len(),12 )),13 syn::Fields::Unnamed(ref fields) => Ok((14 false,15 fields.unnamed.iter().enumerate().map(map_field_to_name),16 fields.unnamed.iter().map(map_field_to_type),17 fields.unnamed.len(),18 )),19 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),20 },21 syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),22 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),23 }?;2425 if params_count == 0 {26 return Err(syn::Error::new(name.span(), "Empty structs not supported"));27 };2829 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);30 let abi_type = impl_abi_type(name, field_types.clone());31 let abi_read = impl_abi_read(32 name,33 is_named_fields,34 field_names.clone(),35 field_types.clone(),36 );37 let abi_write = impl_abi_write(name, is_named_fields, params_count, field_names.clone());38 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);39 let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);40 let solidity_struct_collect = impl_solidity_struct_collect(name, field_names, field_types);4142 Ok(quote! {43 #can_be_plcaed_in_vec44 #abi_type45 #abi_read46 #abi_write47 #solidity_type48 #solidity_type_name49 #solidity_struct_collect50 })51}5253fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {54 quote! {55 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}56 }57}5859fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {60 match field.1.ident.as_ref() {61 Some(name) => name.clone(),62 None => {63 let mut name = "field".to_string();64 name.push_str(field.0.to_string().as_str());65 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())66 }67 }68}6970fn map_field_to_type<'a>(field: &'a syn::Field) -> &'a syn::Type {71 &field.ty72}7374fn impl_abi_type<'a>(75 name: &syn::Ident,76 field_types: impl Iterator<Item = &'a syn::Type> + Clone,77) -> proc_macro2::TokenStream {78 let mut params_signature = {79 let types = field_types.clone();80 quote!(81 #(nameof(<#types as ::evm_coder::abi::AbiType>::SIGNATURE) fixed(","))*82 )83 };8485 params_signature.extend(quote!(shift_left(1)));8687 let fields_for_dynamic = field_types.clone();8889 quote! {90 impl ::evm_coder::abi::AbiType for #name {91 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = ::evm_coder::make_signature!(92 new fixed("(")93 #params_signature94 fixed(")")95 );96 fn is_dynamic() -> bool {97 false98 #(99 || <#fields_for_dynamic as ::evm_coder::abi::AbiType>::is_dynamic()100 )*101 }102 fn size() -> usize {103 0 #(+ <#field_types as ::evm_coder::abi::AbiType>::size())*104 }105 }106 }107}108109fn impl_abi_read<'a>(110 name: &syn::Ident,111 is_named_fields: bool,112 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,113 field_types: impl Iterator<Item = &'a syn::Type> + Clone,114) -> proc_macro2::TokenStream {115 let field_names1 = field_names.clone();116117 let struct_constructor = if is_named_fields {118 quote!(Ok(Self { #(#field_names1),* }))119 } else {120 quote!(Ok(Self ( #(#field_names1),* )))121 };122 quote!(123 impl ::evm_coder::abi::AbiRead for #name {124 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {125 let is_dynamic = <Self as ::evm_coder::abi::AbiType>::is_dynamic();126 let size = if !is_dynamic {127 Some(<Self as ::evm_coder::abi::AbiType>::size())128 } else {129 None130 };131 let mut subresult = reader.subresult(size)?;132 #(133 let #field_names = {134 let value = <#field_types as ::evm_coder::abi::AbiRead>::abi_read(&mut subresult)?;135 if !is_dynamic {subresult.bytes_read(<#field_types as ::evm_coder::abi::AbiType>::size())};136 value137 };138 )*139140 #struct_constructor141 }142 }143 )144}145146fn impl_abi_write<'a>(147 name: &syn::Ident,148 is_named_fields: bool,149 params_count: usize,150 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,151) -> proc_macro2::TokenStream {152 let abi_write = if is_named_fields {153 quote!(154 #(155 ::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);156 )*157 )158 } else {159 let field_names = (0..params_count)160 .into_iter()161 .map(proc_macro2::Literal::usize_unsuffixed);162 quote!(163 #(164 ::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);165 )*166 )167 };168 quote!(169 impl ::evm_coder::abi::AbiWrite for #name {170 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {171 if <Self as ::evm_coder::abi::AbiType>::is_dynamic() {172 let mut sub = ::evm_coder::abi::AbiWriter::new();173 {174 let sub = &mut sub;175 #abi_write176 }177 writer.write_subresult(sub);178 } else {179 let sub = writer;180 #abi_write181 }182 }183 }184 )185}186187fn impl_solidity_type<'a>(188 name: &syn::Ident,189 field_types: impl Iterator<Item = &'a syn::Type> + Clone,190 params_count: usize,191) -> proc_macro2::TokenStream {192 let len = proc_macro2::Literal::usize_suffixed(params_count);193 quote! {194 #[cfg(feature = "stubgen")]195 impl ::evm_coder::solidity::SolidityType for #name {196 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {197 let mut collected =198 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());199 #({200 let mut out = String::new();201 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)202 .expect("no fmt error");203 collected.push(out);204 })*205 collected206 }207208 fn len() -> usize {209 #len210 }211 }212 }213}214215fn impl_solidity_type_name<'a>(216 name: &syn::Ident,217 field_types: impl Iterator<Item = &'a syn::Type> + Clone,218 params_count: usize,219) -> proc_macro2::TokenStream {220 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {221 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName222 >::solidity_default(writer, tc)?;);223 let last_item = params_count - 1;224 if i != last_item {225 defult_value.extend(quote! {write!(writer, ",")?;})226 }227 defult_value228 });229230 quote! {231 #[cfg(feature = "stubgen")]232 impl ::evm_coder::solidity::SolidityTypeName for #name {233 fn solidity_name(234 writer: &mut impl ::core::fmt::Write,235 tc: &::evm_coder::solidity::TypeCollector,236 ) -> ::core::fmt::Result {237 write!(writer, "{}", tc.collect_struct::<Self>())238 }239240 fn is_simple() -> bool {241 false242 }243244 fn solidity_default(245 writer: &mut impl ::core::fmt::Write,246 tc: &::evm_coder::solidity::TypeCollector,247 ) -> ::core::fmt::Result {248 write!(writer, "{}(", tc.collect_struct::<Self>())?;249250 #(#arg_dafaults)*251252 write!(writer, ")")253 }254 }255 }256}257258fn impl_solidity_struct_collect<'a>(259 name: &syn::Ident,260 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,261 field_types: impl Iterator<Item = &'a syn::Type> + Clone,262) -> proc_macro2::TokenStream {263 let string_name = name.to_string();264 let name_type = field_names265 .into_iter()266 .zip(field_types.into_iter())267 .map(|(name, ty)| {268 let name = format!("{}", name);269 quote!(270 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();271 write!(str, "{};", #name).unwrap();272 )273 });274275 quote! {276 #[cfg(feature = "stubgen")]277 impl ::evm_coder::solidity::StructCollect for #name {278 fn name() -> String {279 #string_name.into()280 }281282 fn declaration() -> String {283 use std::fmt::Write;284285 let mut str = String::new();286 writeln!(str, "/// @dev Cross account struct").unwrap();287 writeln!(str, "struct {} {{", Self::name()).unwrap();288 #(#name_type)*289 writeln!(str, "}}").unwrap();290 str291 }292 }293 }294}