difftreelog
refactor external generation of call parsers
in: master
4 files changed
crates/evm-coder-macros/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder-macros/src/lib.rs
+++ b/crates/evm-coder-macros/src/lib.rs
@@ -5,10 +5,7 @@
use proc_macro::TokenStream;
use quote::quote;
use sha3::{Digest, Keccak256};
-use syn::{
- AttributeArgs, DeriveInput, GenericArgument, Ident, ItemTrait, Pat, Path, PathArguments,
- PathSegment, Type, parse_macro_input, spanned::Spanned,
-};
+use syn::{AttributeArgs, DeriveInput, GenericArgument, Ident, ItemImpl, Pat, Path, PathArguments, PathSegment, Type, parse_macro_input, spanned::Spanned};
mod solidity_interface;
mod to_log;
@@ -189,16 +186,21 @@
let args = parse_macro_input!(args as AttributeArgs);
let args = solidity_interface::InterfaceInfo::from_list(&args).unwrap();
- let input: ItemTrait = match syn::parse(stream) {
+ let input: ItemImpl = match syn::parse(stream) {
Ok(t) => t,
Err(e) => return e.to_compile_error().into(),
};
- match solidity_interface::SolidityInterface::try_from(args, &input) {
+ let expanded = match solidity_interface::SolidityInterface::try_from(args, &input) {
Ok(v) => v.expand(),
Err(e) => e.to_compile_error(),
- }
- .into()
+ };
+
+ (quote! {
+ #input
+
+ #expanded
+ }).into()
}
#[proc_macro_attribute]
crates/evm-coder-macros/src/solidity_interface.rsdiffbeforeafterboth1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{FnArg, Ident, ItemTrait, Meta, NestedMeta, PatType, Path, ReturnType, TraitItem, TraitItemMethod, Type, Visibility, spanned::Spanned};89use crate::{10 fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,11 parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,12 snake_ident_to_screaming,13};1415struct Is {16 name: Ident,17 pascal_call_name: Ident,18 snake_call_name: Ident,19}20impl Is {21 fn try_from(path: &Path) -> syn::Result<Self> {22 let name = parse_ident_from_path(path)?.clone();23 Ok(Self {24 pascal_call_name: pascal_ident_to_call(&name),25 snake_call_name: pascal_ident_to_snake_call(&name),26 name,27 })28 }2930 fn expand_call_def(&self) -> proc_macro2::TokenStream {31 let name = &self.name;32 let pascal_call_name = &self.pascal_call_name;33 quote! {34 #name(#pascal_call_name)35 }36 }3738 fn expand_interface_id(&self) -> proc_macro2::TokenStream {39 let pascal_call_name = &self.pascal_call_name;40 quote! {41 interface_id ^= #pascal_call_name::interface_id();42 }43 }4445 fn expand_supports_interface(&self) -> proc_macro2::TokenStream {46 let pascal_call_name = &self.pascal_call_name;47 quote! {48 #pascal_call_name::supports_interface(interface_id)49 }50 }5152 fn expand_variant_call(&self) -> proc_macro2::TokenStream {53 let name = &self.name;54 let snake_call_name = &self.snake_call_name;55 quote! {56 InternalCall::#name(call) => return self.#snake_call_name(Msg {57 call,58 caller: c.caller,59 value: c.value,60 })61 }62 }6364 fn expand_call_inner(&self) -> proc_macro2::TokenStream {65 let snake_call_name = &self.snake_call_name;66 let pascal_call_name = &self.pascal_call_name;67 quote! {68 fn #snake_call_name(&mut self, c: Msg<#pascal_call_name>) -> Result<::evm_coder::abi::AbiWriter>;69 }70 }7172 fn expand_parse(&self) -> proc_macro2::TokenStream {73 let name = &self.name;74 let pascal_call_name = &self.pascal_call_name;75 quote! {76 if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {77 return Ok(Some(Self::#name(parsed_call)))78 }79 }80 }81}8283#[derive(Default)]84struct IsList(Vec<Is>);85impl FromMeta for IsList {86 fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {87 let mut out = Vec::new();88 for item in items {89 match item {90 NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),91 _ => return Err(syn::Error::new(item.span(), "expected path").into()),92 }93 }94 Ok(Self(out))95 }96}9798#[derive(FromMeta)]99pub struct InterfaceInfo {100 #[darling(default)]101 is: IsList,102 #[darling(default)]103 inline_is: IsList,104 #[darling(default)]105 events: IsList,106}107108#[derive(FromMeta)]109struct MethodInfo {110 #[darling(default)]111 rename_selector: Option<String>,112}113114struct MethodArg {115 name: Ident,116 ty: Ident,117}118impl MethodArg {119 fn try_from(value: &PatType) -> syn::Result<Self> {120 Ok(Self {121 name: parse_ident_from_pat(&value.pat)?.clone(),122 ty: parse_ident_from_type(&value.ty)?.clone(),123 })124 }125 fn is_value(&self) -> bool {126 self.ty == "value"127 }128 fn is_caller(&self) -> bool {129 self.ty == "caller"130 }131 fn is_special(&self) -> bool {132 self.is_value() || self.is_caller()133 }134 fn selector_ty(&self) -> &Ident {135 assert!(!self.is_special());136 &self.ty137 }138139 fn expand_call_def(&self) -> proc_macro2::TokenStream {140 assert!(!self.is_special());141 let name = &self.name;142 let ty = &self.ty;143144 quote! {145 #name: #ty146 }147 }148149 fn expand_parse(&self) -> proc_macro2::TokenStream {150 assert!(!self.is_special());151 let name = &self.name;152 quote! {153 #name: reader.abi_read()?154 }155 }156157 fn expand_call_arg(&self) -> proc_macro2::TokenStream {158 if self.is_value() {159 quote! {160 c.value.clone()161 }162 } else if self.is_caller() {163 quote! {164 c.caller.clone()165 }166 } else {167 let name = &self.name;168 quote! {169 #name170 }171 }172 }173}174175#[derive(PartialEq)]176enum Mutability {177 Mutable,178 View,179 Pure,180}181182struct Method {183 name: Ident,184 camel_name: String,185 pascal_name: Ident,186 screaming_name: Ident,187 selector_str: String,188 selector: u32,189 args: Vec<MethodArg>,190 has_normal_args: bool,191 mutability: Mutability,192 result: Type,193}194impl Method {195 fn try_from(value: &TraitItemMethod) -> syn::Result<Self> {196 let mut info = MethodInfo {197 rename_selector: None,198 };199 for attr in &value.attrs {200 let ident = parse_ident_from_path(&attr.path)?;201 if ident == "solidity" {202 let args = attr.parse_meta().unwrap();203 info = MethodInfo::from_meta(&args).unwrap();204 } else if ident == "doc" {205 // TODO: Add docs to evm interfaces206 }207 }208 let ident = &value.sig.ident;209 let ident_str = ident.to_string();210 if !cases::snakecase::is_snake_case(&ident_str) {211 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));212 }213214 let mut mutability = Mutability::Pure;215216 if let Some(FnArg::Receiver(receiver)) = value217 .sig218 .inputs219 .iter()220 .find(|arg| matches!(arg, FnArg::Receiver(_)))221 {222 if receiver.reference.is_none() {223 return Err(syn::Error::new(224 receiver.span(),225 "receiver should be by ref",226 ));227 }228 if receiver.mutability.is_some() {229 mutability = Mutability::Mutable;230 } else {231 mutability = Mutability::View;232 }233 }234 let mut args = Vec::new();235 for typ in value236 .sig237 .inputs238 .iter()239 .filter(|arg| matches!(arg, FnArg::Typed(_)))240 {241 let typ = match typ {242 FnArg::Typed(typ) => typ,243 _ => unreachable!(),244 };245 args.push(MethodArg::try_from(typ)?);246 }247248 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {249 return Err(syn::Error::new(250 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),251 "payable function should be mutable",252 ));253 }254255 let result = match &value.sig.output {256 ReturnType::Type(_, ty) => ty,257 _ => return Err(syn::Error::new(value.sig.output.span(), "interface method should return Result<value>\nif there is no value to return - specify void (which is alias to unit)")),258 };259 let result = parse_result_ok(result)?;260261 let camel_name = info262 .rename_selector263 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));264 let mut selector_str = camel_name.clone();265 selector_str.push('(');266 let mut has_normal_args = false;267 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {268 if i != 0 {269 selector_str.push(',');270 }271 write!(selector_str, "{}", arg.selector_ty()).unwrap();272 has_normal_args = true;273 }274 selector_str.push(')');275 let selector = fn_selector_str(&selector_str);276277 Ok(Self {278 name: ident.clone(),279 camel_name,280 pascal_name: snake_ident_to_pascal(ident),281 screaming_name: snake_ident_to_screaming(ident),282 selector_str,283 selector,284 args,285 has_normal_args,286 mutability,287 result: result.clone(),288 })289 }290 fn expand_call_def(&self) -> proc_macro2::TokenStream {291 let defs = self292 .args293 .iter()294 .filter(|a| !a.is_special())295 .map(|a| a.expand_call_def());296 let pascal_name = &self.pascal_name;297298 if self.has_normal_args {299 quote! {300 #pascal_name {301 #(302 #defs,303 )*304 }305 }306 } else {307 quote! {#pascal_name}308 }309 }310311 fn expand_const(&self) -> proc_macro2::TokenStream {312 let screaming_name = &self.screaming_name;313 let selector = self.selector;314 let selector_str = &self.selector_str;315 quote! {316 #[doc = #selector_str]317 const #screaming_name: u32 = #selector;318 }319 }320321 fn expand_interface_id(&self) -> proc_macro2::TokenStream {322 let screaming_name = &self.screaming_name;323 quote! {324 interface_id ^= Self::#screaming_name;325 }326 }327328 fn expand_parse(&self) -> proc_macro2::TokenStream {329 let pascal_name = &self.pascal_name;330 let screaming_name = &self.screaming_name;331 if self.has_normal_args {332 let parsers = self333 .args334 .iter()335 .filter(|a| !a.is_special())336 .map(|a| a.expand_parse());337 quote! {338 Self::#screaming_name => return Ok(Some(Self::#pascal_name {339 #(340 #parsers,341 )*342 }))343 }344 } else {345 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }346 }347 }348349 fn expand_variant_call(&self) -> proc_macro2::TokenStream {350 let pascal_name = &self.pascal_name;351 let name = &self.name;352353 let matcher = if self.has_normal_args {354 let names = self355 .args356 .iter()357 .filter(|a| !a.is_special())358 .map(|a| &a.name);359360 quote! {{361 #(362 #names,363 )*364 }}365 } else {366 quote! {}367 };368369 let receiver = match self.mutability {370 Mutability::Mutable | Mutability::View => quote! {self.},371 Mutability::Pure => quote! {Self::},372 };373 let args = self.args.iter().map(|a| a.expand_call_arg());374375 quote! {376 InternalCall::#pascal_name #matcher => {377 let result = #receiver #name(378 #(379 #args,380 )*381 )?;382 (&result).abi_write(&mut writer);383 }384 }385 }386}387388pub struct SolidityInterface {389 vis: Visibility,390 name: Ident,391 info: InterfaceInfo,392 methods: Vec<Method>,393 items: Vec<TraitItem>,394}395impl SolidityInterface {396 pub fn try_from(info: InterfaceInfo, value: &ItemTrait) -> syn::Result<Self> {397 let mut methods = Vec::new();398399 for item in &value.items {400 match item {401 TraitItem::Method(method) => methods.push(Method::try_from(method)?),402 _ => {}403 }404 }405 Ok(Self {406 vis: value.vis.clone(),407 name: value.ident.clone(),408 info,409 methods,410 items: value.items.clone(),411 })412 }413 pub fn expand(self) -> proc_macro2::TokenStream {414 let vis = self.vis;415 let name = self.name;416 let items = self.items;417418 let call_name = pascal_ident_to_call(&name);419420 let call_sub = self421 .info422 .inline_is423 .0424 .iter()425 .chain(self.info.is.0.iter())426 .map(Is::expand_call_def);427 let call_inner = self428 .info429 .inline_is430 .0431 .iter()432 .chain(self.info.is.0.iter())433 .map(Is::expand_call_inner);434 let call_parse = self435 .info436 .inline_is437 .0438 .iter()439 .chain(self.info.is.0.iter())440 .map(Is::expand_parse);441 let call_variants = self442 .info443 .inline_is444 .0445 .iter()446 .chain(self.info.is.0.iter())447 .map(Is::expand_variant_call);448449 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);450 let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);451452 let calls = self.methods.iter().map(Method::expand_call_def);453 let consts = self.methods.iter().map(Method::expand_const);454 let interface_id = self.methods.iter().map(Method::expand_interface_id);455 let parsers = self.methods.iter().map(Method::expand_parse);456 let call_variants_this = self.methods.iter().map(Method::expand_variant_call);457458 // let methods = self.methods.iter().map(Method::solidity_def);459460 quote! {461 #[derive(Debug)]462 #vis enum #call_name {463 #(464 #calls,465 )*466 #(467 #call_sub,468 )*469 }470 impl #call_name {471 #(472 #consts473 )*474 pub const fn interface_id() -> u32 {475 let mut interface_id = 0;476 #(#interface_id)*477 #(#inline_interface_id)*478 interface_id479 }480 pub fn supports_interface(interface_id: u32) -> bool {481 interface_id != 0xffffff && (482 interface_id == Self::interface_id()483 #(484 || #supports_interface485 )*486 )487 }488 }489 impl ::evm_coder::Call for #call_name {490 fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {491 use ::evm_coder::abi::AbiRead;492 match method_id {493 #(494 #parsers,495 )*496 _ => {},497 }498 #(499 #call_parse500 )else*501 return Ok(None);502 }503 }504 #vis trait #name {505 #(506 #items507 )*508 #(509 #call_inner510 )*511 }512 impl<T> ::evm_coder::Callable for T where T: #name {513 type Call = #call_name;514 #[allow(unreachable_code)] // In case of no inner calls515 fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {516 use ::evm_coder::abi::AbiWrite;517 type InternalCall = #call_name;518 match c.call {519 #(520 #call_variants,521 )*522 _ => {},523 }524 let mut writer = ::evm_coder::abi::AbiWriter::default();525 match c.call {526 #(527 #call_variants_this,528 )*529 _ => unreachable!()530 }531 Ok(writer)532 }533 }534 }535 }536}1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{8 FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl, Meta, NestedMeta, PatType, Path, ReturnType,9 Type, spanned::Spanned,10};1112use crate::{13 fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,14 parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,15 snake_ident_to_screaming,16};1718struct Is {19 name: Ident,20 pascal_call_name: Ident,21 snake_call_name: Ident,22}23impl Is {24 fn try_from(path: &Path) -> syn::Result<Self> {25 let name = parse_ident_from_path(path)?.clone();26 Ok(Self {27 pascal_call_name: pascal_ident_to_call(&name),28 snake_call_name: pascal_ident_to_snake_call(&name),29 name,30 })31 }3233 fn expand_call_def(&self) -> proc_macro2::TokenStream {34 let name = &self.name;35 let pascal_call_name = &self.pascal_call_name;36 quote! {37 #name(#pascal_call_name)38 }39 }4041 fn expand_interface_id(&self) -> proc_macro2::TokenStream {42 let pascal_call_name = &self.pascal_call_name;43 quote! {44 interface_id ^= #pascal_call_name::interface_id();45 }46 }4748 fn expand_supports_interface(&self) -> proc_macro2::TokenStream {49 let pascal_call_name = &self.pascal_call_name;50 quote! {51 #pascal_call_name::supports_interface(interface_id)52 }53 }5455 fn expand_variant_call(&self) -> proc_macro2::TokenStream {56 let name = &self.name;57 let pascal_call_name = &self.pascal_call_name;58 quote! {59 InternalCall::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name>>::call(self, Msg {60 call,61 caller: c.caller,62 value: c.value,63 })64 }65 }6667 fn expand_parse(&self) -> proc_macro2::TokenStream {68 let name = &self.name;69 let pascal_call_name = &self.pascal_call_name;70 quote! {71 if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {72 return Ok(Some(Self::#name(parsed_call)))73 }74 }75 }76}7778#[derive(Default)]79struct IsList(Vec<Is>);80impl FromMeta for IsList {81 fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {82 let mut out = Vec::new();83 for item in items {84 match item {85 NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),86 _ => return Err(syn::Error::new(item.span(), "expected path").into()),87 }88 }89 Ok(Self(out))90 }91}9293#[derive(FromMeta)]94pub struct InterfaceInfo {95 name: Ident,96 #[darling(default)]97 is: IsList,98 #[darling(default)]99 inline_is: IsList,100 #[darling(default)]101 events: IsList,102}103104#[derive(FromMeta)]105struct MethodInfo {106 #[darling(default)]107 rename_selector: Option<String>,108}109110struct MethodArg {111 name: Ident,112 ty: Ident,113}114impl MethodArg {115 fn try_from(value: &PatType) -> syn::Result<Self> {116 Ok(Self {117 name: parse_ident_from_pat(&value.pat)?.clone(),118 ty: parse_ident_from_type(&value.ty)?.clone(),119 })120 }121 fn is_value(&self) -> bool {122 self.ty == "value"123 }124 fn is_caller(&self) -> bool {125 self.ty == "caller"126 }127 fn is_special(&self) -> bool {128 self.is_value() || self.is_caller()129 }130 fn selector_ty(&self) -> &Ident {131 assert!(!self.is_special());132 &self.ty133 }134135 fn expand_call_def(&self) -> proc_macro2::TokenStream {136 assert!(!self.is_special());137 let name = &self.name;138 let ty = &self.ty;139140 quote! {141 #name: #ty142 }143 }144145 fn expand_parse(&self) -> proc_macro2::TokenStream {146 assert!(!self.is_special());147 let name = &self.name;148 quote! {149 #name: reader.abi_read()?150 }151 }152153 fn expand_call_arg(&self) -> proc_macro2::TokenStream {154 if self.is_value() {155 quote! {156 c.value.clone()157 }158 } else if self.is_caller() {159 quote! {160 c.caller.clone()161 }162 } else {163 let name = &self.name;164 quote! {165 #name166 }167 }168 }169}170171#[derive(PartialEq)]172enum Mutability {173 Mutable,174 View,175 Pure,176}177178struct Method {179 name: Ident,180 camel_name: String,181 pascal_name: Ident,182 screaming_name: Ident,183 selector_str: String,184 selector: u32,185 args: Vec<MethodArg>,186 has_normal_args: bool,187 mutability: Mutability,188 result: Type,189}190impl Method {191 fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {192 let mut info = MethodInfo {193 rename_selector: None,194 };195 for attr in &value.attrs {196 let ident = parse_ident_from_path(&attr.path)?;197 if ident == "solidity" {198 let args = attr.parse_meta().unwrap();199 info = MethodInfo::from_meta(&args).unwrap();200 } else if ident == "doc" {201 // TODO: Add docs to evm interfaces202 }203 }204 let ident = &value.sig.ident;205 let ident_str = ident.to_string();206 if !cases::snakecase::is_snake_case(&ident_str) {207 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));208 }209210 let mut mutability = Mutability::Pure;211212 if let Some(FnArg::Receiver(receiver)) = value213 .sig214 .inputs215 .iter()216 .find(|arg| matches!(arg, FnArg::Receiver(_)))217 {218 if receiver.reference.is_none() {219 return Err(syn::Error::new(220 receiver.span(),221 "receiver should be by ref",222 ));223 }224 if receiver.mutability.is_some() {225 mutability = Mutability::Mutable;226 } else {227 mutability = Mutability::View;228 }229 }230 let mut args = Vec::new();231 for typ in value232 .sig233 .inputs234 .iter()235 .filter(|arg| matches!(arg, FnArg::Typed(_)))236 {237 let typ = match typ {238 FnArg::Typed(typ) => typ,239 _ => unreachable!(),240 };241 args.push(MethodArg::try_from(typ)?);242 }243244 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {245 return Err(syn::Error::new(246 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),247 "payable function should be mutable",248 ));249 }250251 let result = match &value.sig.output {252 ReturnType::Type(_, ty) => ty,253 _ => return Err(syn::Error::new(value.sig.output.span(), "interface method should return Result<value>\nif there is no value to return - specify void (which is alias to unit)")),254 };255 let result = parse_result_ok(result)?;256257 let camel_name = info258 .rename_selector259 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));260 let mut selector_str = camel_name.clone();261 selector_str.push('(');262 let mut has_normal_args = false;263 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {264 if i != 0 {265 selector_str.push(',');266 }267 write!(selector_str, "{}", arg.selector_ty()).unwrap();268 has_normal_args = true;269 }270 selector_str.push(')');271 let selector = fn_selector_str(&selector_str);272273 Ok(Self {274 name: ident.clone(),275 camel_name,276 pascal_name: snake_ident_to_pascal(ident),277 screaming_name: snake_ident_to_screaming(ident),278 selector_str,279 selector,280 args,281 has_normal_args,282 mutability,283 result: result.clone(),284 })285 }286 fn expand_call_def(&self) -> proc_macro2::TokenStream {287 let defs = self288 .args289 .iter()290 .filter(|a| !a.is_special())291 .map(|a| a.expand_call_def());292 let pascal_name = &self.pascal_name;293294 if self.has_normal_args {295 quote! {296 #pascal_name {297 #(298 #defs,299 )*300 }301 }302 } else {303 quote! {#pascal_name}304 }305 }306307 fn expand_const(&self) -> proc_macro2::TokenStream {308 let screaming_name = &self.screaming_name;309 let selector = self.selector;310 let selector_str = &self.selector_str;311 quote! {312 #[doc = #selector_str]313 const #screaming_name: u32 = #selector;314 }315 }316317 fn expand_interface_id(&self) -> proc_macro2::TokenStream {318 let screaming_name = &self.screaming_name;319 quote! {320 interface_id ^= Self::#screaming_name;321 }322 }323324 fn expand_parse(&self) -> proc_macro2::TokenStream {325 let pascal_name = &self.pascal_name;326 let screaming_name = &self.screaming_name;327 if self.has_normal_args {328 let parsers = self329 .args330 .iter()331 .filter(|a| !a.is_special())332 .map(|a| a.expand_parse());333 quote! {334 Self::#screaming_name => return Ok(Some(Self::#pascal_name {335 #(336 #parsers,337 )*338 }))339 }340 } else {341 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }342 }343 }344345 fn expand_variant_call(&self) -> proc_macro2::TokenStream {346 let pascal_name = &self.pascal_name;347 let name = &self.name;348349 let matcher = if self.has_normal_args {350 let names = self351 .args352 .iter()353 .filter(|a| !a.is_special())354 .map(|a| &a.name);355356 quote! {{357 #(358 #names,359 )*360 }}361 } else {362 quote! {}363 };364365 let receiver = match self.mutability {366 Mutability::Mutable | Mutability::View => quote! {self.},367 Mutability::Pure => quote! {Self::},368 };369 let args = self.args.iter().map(|a| a.expand_call_arg());370371 quote! {372 InternalCall::#pascal_name #matcher => {373 let result = #receiver #name(374 #(375 #args,376 )*377 )?;378 (&result).abi_write(&mut writer);379 }380 }381 }382}383384pub struct SolidityInterface {385 name: Box<syn::Type>,386 ident: Ident,387 info: InterfaceInfo,388 methods: Vec<Method>,389}390impl SolidityInterface {391 pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {392 let mut methods = Vec::new();393394 for item in &value.items {395 if let ImplItem::Method(method) = item {396 methods.push(Method::try_from(method)?)397 }398 }399 Ok(Self {400 name: value.self_ty.clone(),401 ident: parse_ident_from_type(&value.self_ty)?.clone(),402 info,403 methods,404 })405 }406 pub fn expand(self) -> proc_macro2::TokenStream {407 let name = self.name;408409 let call_name = pascal_ident_to_call(&self.info.name);410411 let call_sub = self412 .info413 .inline_is414 .0415 .iter()416 .chain(self.info.is.0.iter())417 .map(Is::expand_call_def);418 let call_parse = self419 .info420 .inline_is421 .0422 .iter()423 .chain(self.info.is.0.iter())424 .map(Is::expand_parse);425 let call_variants = self426 .info427 .inline_is428 .0429 .iter()430 .chain(self.info.is.0.iter())431 .map(Is::expand_variant_call);432433 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);434 let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);435436 let calls = self.methods.iter().map(Method::expand_call_def);437 let consts = self.methods.iter().map(Method::expand_const);438 let interface_id = self.methods.iter().map(Method::expand_interface_id);439 let parsers = self.methods.iter().map(Method::expand_parse);440 let call_variants_this = self.methods.iter().map(Method::expand_variant_call);441442 // let methods = self.methods.iter().map(Method::solidity_def);443444 quote! {445 #[derive(Debug)]446 pub enum #call_name {447 #(448 #calls,449 )*450 #(451 #call_sub,452 )*453 }454 impl #call_name {455 #(456 #consts457 )*458 pub const fn interface_id() -> u32 {459 let mut interface_id = 0;460 #(#interface_id)*461 #(#inline_interface_id)*462 interface_id463 }464 pub fn supports_interface(interface_id: u32) -> bool {465 interface_id != 0xffffff && (466 interface_id == Self::interface_id()467 #(468 || #supports_interface469 )*470 )471 }472 }473 impl ::evm_coder::Call for #call_name {474 fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {475 use ::evm_coder::abi::AbiRead;476 match method_id {477 #(478 #parsers,479 )*480 _ => {},481 }482 #(483 #call_parse484 )else*485 return Ok(None);486 }487 }488 impl ::evm_coder::Callable<#call_name> for #name {489 #[allow(unreachable_code)] // In case of no inner calls490 fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {491 use ::evm_coder::abi::AbiWrite;492 type InternalCall = #call_name;493 match c.call {494 #(495 #call_variants,496 )*497 _ => {},498 }499 let mut writer = ::evm_coder::abi::AbiWriter::default();500 match c.call {501 #(502 #call_variants_this,503 )*504 _ => unreachable!()505 }506 Ok(writer)507 }508 }509 }510 }511}crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -57,9 +57,8 @@
fn parse(selector: u32, input: &mut AbiReader) -> execution::Result<Option<Self>>;
}
-pub trait Callable {
- type Call: Call;
- fn call(&mut self, call: types::Msg<Self::Call>) -> execution::Result<AbiWriter>;
+pub trait Callable<C: Call> {
+ fn call(&mut self, call: types::Msg<C>) -> execution::Result<AbiWriter>;
}
#[cfg(test)]
crates/evm-coder/tests/a.rsdiffbeforeafterboth--- a/crates/evm-coder/tests/a.rs
+++ b/crates/evm-coder/tests/a.rs
@@ -3,24 +3,38 @@
use evm_coder::{solidity_interface, types::*, ToLog, execution::Result};
use evm_coder_macros::solidity;
-#[solidity_interface]
-trait OurInterface {
- fn fn_a(&self, input: uint256) -> Result<bool>;
+struct Impls;
+
+#[solidity_interface(name = "OurInterface")]
+impl Impls {
+ fn fn_a(&self, input: uint256) -> Result<bool> {
+ todo!()
+ }
}
-#[solidity_interface]
-trait OurInterface1 {
- fn fn_b(&self, input: uint128) -> Result<uint32>;
+#[solidity_interface(name = "OurInterface1")]
+impl Impls {
+ fn fn_b(&self, input: uint128) -> Result<uint32> {
+ todo!()
+ }
}
-#[solidity_interface(is(OurInterface), inline_is(OurInterface1), events(ERC721Log))]
-trait OurInterface2 {
+#[solidity_interface(name = "OurInterface2", is(OurInterface), inline_is(OurInterface1), events(ERC721Log))]
+impl Impls {
#[solidity(rename_selector = "fnK")]
- fn fn_c(&self, input: uint32) -> Result<uint8>;
- fn fn_d(&self, value: uint32) -> Result<uint32>;
+ fn fn_c(&self, input: uint32) -> Result<uint8> {
+ todo!()
+ }
+ fn fn_d(&self, value: uint32) -> Result<uint32> {
+ todo!()
+ }
- fn caller_sensitive(&self, caller: caller) -> Result<uint8>;
- fn payable(&mut self, value: value) -> Result<uint8>;
+ fn caller_sensitive(&self, caller: caller) -> Result<uint8> {
+ todo!()
+ }
+ fn payable(&mut self, value: value) -> Result<uint8> {
+ todo!()
+ }
}
#[derive(ToLog)]
@@ -39,18 +53,32 @@
},
}
-#[solidity_interface]
-trait ERC20 {
- fn decimals(&self) -> Result<uint8>;
- fn balance_of(&self, owner: address) -> Result<uint256>;
- fn transfer(&mut self, caller: caller, to: address, value: uint256) -> Result<bool>;
+struct ERC20;
+
+#[solidity_interface(name = "ERC20")]
+impl ERC20 {
+ fn decimals(&self) -> Result<uint8> {
+ todo!()
+ }
+ fn balance_of(&self, owner: address) -> Result<uint256> {
+ todo!()
+ }
+ fn transfer(&mut self, caller: caller, to: address, value: uint256) -> Result<bool> {
+ todo!()
+ }
fn transfer_from(
&mut self,
caller: caller,
from: address,
to: address,
value: uint256,
- ) -> Result<bool>;
- fn approve(&mut self, caller: caller, spender: address, value: uint256) -> Result<bool>;
- fn allowance(&self, owner: address, spender: address) -> Result<uint256>;
+ ) -> Result<bool> {
+ todo!()
+ }
+ fn approve(&mut self, caller: caller, spender: address, value: uint256) -> Result<bool> {
+ todo!()
+ }
+ fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
+ todo!()
+ }
}