1#![allow(dead_code)]23use darling::FromMeta;4use inflector::cases;5use proc_macro::TokenStream;6use quote::quote;7use sha3::{Digest, Keccak256};8use syn::{9 AttributeArgs, DeriveInput, GenericArgument, Ident, ItemImpl, Pat, Path, PathArguments,10 PathSegment, Type, parse_macro_input, spanned::Spanned,11};1213mod solidity_interface;14mod to_log;1516fn fn_selector_str(input: &str) -> u32 {17 let mut hasher = Keccak256::new();18 hasher.update(input.as_bytes());19 let result = hasher.finalize();2021 let mut selector_bytes = [0; 4];22 selector_bytes.copy_from_slice(&result[0..4]);2324 u32::from_be_bytes(selector_bytes)25}26272829303132333435#[proc_macro]36pub fn fn_selector(input: TokenStream) -> TokenStream {37 let input = input.to_string().replace(' ', "");38 let selector = fn_selector_str(&input);3940 (quote! {41 #selector42 })43 .into()44}4546fn event_selector_str(input: &str) -> [u8; 32] {47 let mut hasher = Keccak256::new();48 hasher.update(input.as_bytes());49 let result = hasher.finalize();5051 let mut selector_bytes = [0; 32];52 selector_bytes.copy_from_slice(&result[0..32]);53 selector_bytes54}555657585960616263646566#[proc_macro]67pub fn event_topic(stream: TokenStream) -> TokenStream {68 let input = stream.to_string().replace(' ', "");69 let selector_bytes = event_selector_str(&input);7071 (quote! {72 ::primitive_types::H256([#(73 #selector_bytes,74 )*])75 })76 .into()77}7879fn parse_path(ty: &Type) -> syn::Result<&Path> {80 match &ty {81 syn::Type::Path(pat) => {82 if let Some(qself) = &pat.qself {83 return Err(syn::Error::new(qself.ty.span(), "no receiver expected"));84 }85 Ok(&pat.path)86 }87 _ => Err(syn::Error::new(ty.span(), "expected ty to be path")),88 }89}9091fn parse_path_segment(path: &Path) -> syn::Result<&PathSegment> {92 if path.segments.len() != 1 {93 return Err(syn::Error::new(94 path.span(),95 "expected path to have only segment",96 ));97 }98 let last_segment = &path.segments.last().unwrap();99 Ok(last_segment)100}101102fn parse_ident_from_pat(pat: &Pat) -> syn::Result<&Ident> {103 match pat {104 Pat::Ident(i) => Ok(&i.ident),105 _ => Err(syn::Error::new(pat.span(), "expected pat ident")),106 }107}108109fn parse_ident_from_segment(segment: &PathSegment, allow_generics: bool) -> syn::Result<&Ident> {110 if segment.arguments != PathArguments::None && !allow_generics {111 return Err(syn::Error::new(112 segment.arguments.span(),113 "unexpected generic type",114 ));115 }116 Ok(&segment.ident)117}118119fn parse_ident_from_path(path: &Path, allow_generics: bool) -> syn::Result<&Ident> {120 let segment = parse_path_segment(path)?;121 parse_ident_from_segment(segment, allow_generics)122}123124fn parse_ident_from_type(ty: &Type, allow_generics: bool) -> syn::Result<&Ident> {125 let path = parse_path(ty)?;126 parse_ident_from_path(path, allow_generics)127}128129130fn parse_result_ok(ty: &Type) -> syn::Result<&Type> {131 let path = parse_path(ty)?;132 let segment = parse_path_segment(path)?;133134 if segment.ident != "Result" {135 return Err(syn::Error::new(136 ty.span(),137 "expected Result as return type (no renamed aliases allowed)",138 ));139 }140 let args = match &segment.arguments {141 PathArguments::AngleBracketed(e) => e,142 _ => {143 return Err(syn::Error::new(144 segment.arguments.span(),145 "missing Result generics",146 ))147 }148 };149150 let args = &args.args;151 let arg = args.first().unwrap();152153 let ty = match arg {154 GenericArgument::Type(ty) => ty,155 _ => {156 return Err(syn::Error::new(157 arg.span(),158 "expected first generic to be type",159 ))160 }161 };162163 Ok(ty)164}165166fn pascal_ident_to_call(ident: &Ident) -> Ident {167 let name = format!("{}Call", ident);168 Ident::new(&name, ident.span())169}170fn snake_ident_to_pascal(ident: &Ident) -> Ident {171 let name = ident.to_string();172 let name = cases::pascalcase::to_pascal_case(&name);173 Ident::new(&name, ident.span())174}175fn snake_ident_to_screaming(ident: &Ident) -> Ident {176 let name = ident.to_string();177 let name = cases::screamingsnakecase::to_screaming_snake_case(&name);178 Ident::new(&name, ident.span())179}180fn pascal_ident_to_snake_call(ident: &Ident) -> Ident {181 let name = ident.to_string();182 let name = cases::snakecase::to_snake_case(&name);183 let name = format!("call_{}", name);184 Ident::new(&name, ident.span())185}186187#[proc_macro_attribute]188pub fn solidity_interface(args: TokenStream, stream: TokenStream) -> TokenStream {189 let args = parse_macro_input!(args as AttributeArgs);190 let args = solidity_interface::InterfaceInfo::from_list(&args).unwrap();191192 let input: ItemImpl = match syn::parse(stream) {193 Ok(t) => t,194 Err(e) => return e.to_compile_error().into(),195 };196197 let expanded = match solidity_interface::SolidityInterface::try_from(args, &input) {198 Ok(v) => v.expand(),199 Err(e) => e.to_compile_error(),200 };201202 (quote! {203 #input204205 #expanded206 })207 .into()208}209210#[proc_macro_attribute]211pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {212 stream213}214215#[proc_macro_derive(ToLog, attributes(indexed))]216pub fn to_log(value: TokenStream) -> TokenStream {217 let input = parse_macro_input!(value as DeriveInput);218219 match to_log::Events::try_from(&input) {220 Ok(e) => e.expand(),221 Err(e) => e.to_compile_error(),222 }223 .into()224}