1use darling::FromMeta;2use inflector::cases;3use proc_macro::TokenStream;4use quote::quote;5use sha3::{Digest, Keccak256};6use syn::{7 AttributeArgs, DeriveInput, GenericArgument, Ident, ItemTrait, Pat, Path, PathArguments,8 PathSegment, Type, parse_macro_input, spanned::Spanned,9};1011mod solidity_interface;12mod to_log;1314fn fn_selector_str(input: &str) -> u32 {15 let mut hasher = Keccak256::new();16 hasher.update(input.as_bytes());17 let result = hasher.finalize();1819 let mut selector_bytes = [0; 4];20 selector_bytes.copy_from_slice(&result[0..4]);2122 u32::from_be_bytes(selector_bytes)23}24252627282930313233#[proc_macro]34pub fn fn_selector(input: TokenStream) -> TokenStream {35 let input = input.to_string().replace(' ', "");36 let selector = fn_selector_str(&input);3738 (quote! {39 #selector40 })41 .into()42}4344fn event_selector_str(input: &str) -> [u8; 32] {45 let mut hasher = Keccak256::new();46 hasher.update(input.as_bytes());47 let result = hasher.finalize();4849 let mut selector_bytes = [0; 32];50 selector_bytes.copy_from_slice(&result[0..32]);51 selector_bytes52}535455565758596061626364#[proc_macro]65pub fn event_topic(stream: TokenStream) -> TokenStream {66 let input = stream.to_string().replace(' ', "");67 let selector_bytes = event_selector_str(&input);6869 (quote! {70 ::primitive_types::H256([#(71 #selector_bytes,72 )*])73 })74 .into()75}7677fn parse_path(ty: &Type) -> syn::Result<&Path> {78 match &ty {79 syn::Type::Path(pat) => {80 if let Some(qself) = &pat.qself {81 return Err(syn::Error::new(qself.ty.span(), "no receiver expected"));82 }83 Ok(&pat.path)84 }85 _ => Err(syn::Error::new(ty.span(), "expected ty to be path")),86 }87}8889fn parse_path_segment(path: &Path) -> syn::Result<&PathSegment> {90 if path.segments.len() != 1 {91 return Err(syn::Error::new(92 path.span(),93 "expected path to have only segment",94 ));95 }96 let last_segment = &path.segments.last().unwrap();97 Ok(last_segment)98}99100fn parse_ident_from_pat(pat: &Pat) -> syn::Result<&Ident> {101 match pat {102 Pat::Ident(i) => Ok(&i.ident),103 _ => Err(syn::Error::new(pat.span(), "expected pat ident")),104 }105}106107fn parse_ident_from_segment(segment: &PathSegment) -> syn::Result<&Ident> {108 if segment.arguments != PathArguments::None {109 return Err(syn::Error::new(110 segment.arguments.span(),111 "unexpected generic type",112 ));113 }114 Ok(&segment.ident)115}116117fn parse_ident_from_path(path: &Path) -> syn::Result<&Ident> {118 let segment = parse_path_segment(path)?;119 parse_ident_from_segment(segment)120}121122fn parse_ident_from_type(ty: &Type) -> syn::Result<&Ident> {123 let path = parse_path(ty)?;124 parse_ident_from_path(path)125}126127128fn parse_result_ok(ty: &Type) -> syn::Result<&Ident> {129 let path = parse_path(ty)?;130 let segment = parse_path_segment(path)?;131132 if segment.ident != "Result" {133 return Err(syn::Error::new(134 ty.span(),135 "expected Result as return type (no renamed aliases allowed)",136 ));137 }138 let args = match &segment.arguments {139 PathArguments::AngleBracketed(e) => e,140 _ => {141 return Err(syn::Error::new(142 segment.arguments.span(),143 "missing Result generics",144 ))145 }146 };147148 let args = &args.args;149 let arg = args.first().unwrap();150151 let ty = match arg {152 GenericArgument::Type(ty) => ty,153 _ => {154 return Err(syn::Error::new(155 arg.span(),156 "expected first generic to be type",157 ))158 }159 };160161 parse_ident_from_type(ty)162}163164fn pascal_ident_to_call(ident: &Ident) -> Ident {165 let name = format!("{}Call", ident);166 Ident::new(&name, ident.span())167}168fn snake_ident_to_pascal(ident: &Ident) -> Ident {169 let name = ident.to_string();170 let name = cases::pascalcase::to_pascal_case(&name);171 Ident::new(&name, ident.span())172}173fn snake_ident_to_screaming(ident: &Ident) -> Ident {174 let name = ident.to_string();175 let name = cases::screamingsnakecase::to_screaming_snake_case(&name);176 Ident::new(&name, ident.span())177}178fn pascal_ident_to_snake_call(ident: &Ident) -> Ident {179 let name = ident.to_string();180 let name = cases::snakecase::to_snake_case(&name);181 let name = format!("call_{}", name);182 Ident::new(&name, ident.span())183}184185fn format_ty(ty: &Ident) -> String {186 if ty == "string" {187 format!("{} memory", ty)188 } else {189 ty.to_string()190 }191}192193#[proc_macro_attribute]194pub fn solidity_interface(args: TokenStream, stream: TokenStream) -> TokenStream {195 let args = parse_macro_input!(args as AttributeArgs);196 let args = solidity_interface::InterfaceInfo::from_list(&args).unwrap();197198 let input: ItemTrait = match syn::parse(stream) {199 Ok(t) => t,200 Err(e) => return e.to_compile_error().into(),201 };202203 match solidity_interface::SolidityInterface::try_from(args, &input) {204 Ok(v) => v.expand(),205 Err(e) => e.to_compile_error(),206 }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}