1#![allow(dead_code)]23use darling::FromMeta;4use inflector::cases;5use proc_macro::TokenStream;6use quote::quote;7use sha3::{Digest, Keccak256};8use syn::{AttributeArgs, DeriveInput, GenericArgument, Ident, ItemImpl, Pat, Path, PathArguments, PathSegment, Type, parse_macro_input, spanned::Spanned};910mod solidity_interface;11mod to_log;1213fn fn_selector_str(input: &str) -> u32 {14 let mut hasher = Keccak256::new();15 hasher.update(input.as_bytes());16 let result = hasher.finalize();1718 let mut selector_bytes = [0; 4];19 selector_bytes.copy_from_slice(&result[0..4]);2021 u32::from_be_bytes(selector_bytes)22}23242526272829303132#[proc_macro]33pub fn fn_selector(input: TokenStream) -> TokenStream {34 let input = input.to_string().replace(' ', "");35 let selector = fn_selector_str(&input);3637 (quote! {38 #selector39 })40 .into()41}4243fn event_selector_str(input: &str) -> [u8; 32] {44 let mut hasher = Keccak256::new();45 hasher.update(input.as_bytes());46 let result = hasher.finalize();4748 let mut selector_bytes = [0; 32];49 selector_bytes.copy_from_slice(&result[0..32]);50 selector_bytes51}525354555657585960616263#[proc_macro]64pub fn event_topic(stream: TokenStream) -> TokenStream {65 let input = stream.to_string().replace(' ', "");66 let selector_bytes = event_selector_str(&input);6768 (quote! {69 ::primitive_types::H256([#(70 #selector_bytes,71 )*])72 })73 .into()74}7576fn parse_path(ty: &Type) -> syn::Result<&Path> {77 match &ty {78 syn::Type::Path(pat) => {79 if let Some(qself) = &pat.qself {80 return Err(syn::Error::new(qself.ty.span(), "no receiver expected"));81 }82 Ok(&pat.path)83 }84 _ => Err(syn::Error::new(ty.span(), "expected ty to be path")),85 }86}8788fn parse_path_segment(path: &Path) -> syn::Result<&PathSegment> {89 if path.segments.len() != 1 {90 return Err(syn::Error::new(91 path.span(),92 "expected path to have only segment",93 ));94 }95 let last_segment = &path.segments.last().unwrap();96 Ok(last_segment)97}9899fn parse_ident_from_pat(pat: &Pat) -> syn::Result<&Ident> {100 match pat {101 Pat::Ident(i) => Ok(&i.ident),102 _ => Err(syn::Error::new(pat.span(), "expected pat ident")),103 }104}105106fn parse_ident_from_segment(segment: &PathSegment, allow_generics: bool) -> syn::Result<&Ident> {107 if segment.arguments != PathArguments::None && !allow_generics {108 return Err(syn::Error::new(109 segment.arguments.span(),110 "unexpected generic type",111 ));112 }113 Ok(&segment.ident)114}115116fn parse_ident_from_path(path: &Path, allow_generics: bool) -> syn::Result<&Ident> {117 let segment = parse_path_segment(path)?;118 parse_ident_from_segment(segment, allow_generics)119}120121fn parse_ident_from_type(ty: &Type, allow_generics: bool) -> syn::Result<&Ident> {122 let path = parse_path(ty)?;123 parse_ident_from_path(path, allow_generics)124}125126127fn parse_result_ok(ty: &Type) -> syn::Result<&Type> {128 let path = parse_path(ty)?;129 let segment = parse_path_segment(path)?;130131 if segment.ident != "Result" {132 return Err(syn::Error::new(133 ty.span(),134 "expected Result as return type (no renamed aliases allowed)",135 ));136 }137 let args = match &segment.arguments {138 PathArguments::AngleBracketed(e) => e,139 _ => {140 return Err(syn::Error::new(141 segment.arguments.span(),142 "missing Result generics",143 ))144 }145 };146147 let args = &args.args;148 let arg = args.first().unwrap();149150 let ty = match arg {151 GenericArgument::Type(ty) => ty,152 _ => {153 return Err(syn::Error::new(154 arg.span(),155 "expected first generic to be type",156 ))157 }158 };159160 Ok(ty)161}162163fn pascal_ident_to_call(ident: &Ident) -> Ident {164 let name = format!("{}Call", ident);165 Ident::new(&name, ident.span())166}167fn snake_ident_to_pascal(ident: &Ident) -> Ident {168 let name = ident.to_string();169 let name = cases::pascalcase::to_pascal_case(&name);170 Ident::new(&name, ident.span())171}172fn snake_ident_to_screaming(ident: &Ident) -> Ident {173 let name = ident.to_string();174 let name = cases::screamingsnakecase::to_screaming_snake_case(&name);175 Ident::new(&name, ident.span())176}177fn pascal_ident_to_snake_call(ident: &Ident) -> Ident {178 let name = ident.to_string();179 let name = cases::snakecase::to_snake_case(&name);180 let name = format!("call_{}", name);181 Ident::new(&name, ident.span())182}183184#[proc_macro_attribute]185pub fn solidity_interface(args: TokenStream, stream: TokenStream) -> TokenStream {186 let args = parse_macro_input!(args as AttributeArgs);187 let args = solidity_interface::InterfaceInfo::from_list(&args).unwrap();188189 let input: ItemImpl = match syn::parse(stream) {190 Ok(t) => t,191 Err(e) => return e.to_compile_error().into(),192 };193194 let expanded = match solidity_interface::SolidityInterface::try_from(args, &input) {195 Ok(v) => v.expand(),196 Err(e) => e.to_compile_error(),197 };198199 (quote! {200 #input201202 #expanded203 }).into()204}205206#[proc_macro_attribute]207pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {208 stream209}210211#[proc_macro_derive(ToLog, attributes(indexed))]212pub fn to_log(value: TokenStream) -> TokenStream {213 let input = parse_macro_input!(value as DeriveInput);214215 match to_log::Events::try_from(&input) {216 Ok(e) => e.expand(),217 Err(e) => e.to_compile_error(),218 }219 .into()220}