feat: evm contract calls

contract-derive/Cargo.toml

@@ -9,6 +9,7 @@ quote = "1.0"
 syn = { version = "1.0", features = ["full"] }
 alloy-core = { version = "0.8.20", default-features = false }
 alloy-sol-types = { version = "0.8.20", default-features = false }
+alloy-dyn-abi = { version = "0.8.20", default-features = false }
 
 [lib]
 proc-macro = true

contract-derive/src/helpers.rs

@@ -1,6 +1,14 @@
+use std::error::Error;
+
 use alloy_core::primitives::keccak256;
+use alloy_dyn_abi::DynSolType;
+use alloy_sol_types::SolType;
 use quote::{format_ident, quote};
-use syn::{FnArg, Ident, ImplItemMethod, ReturnType, TraitItemMethod};
+use syn::{
+    parse::{Parse, ParseStream},
+    spanned::Spanned,
+    FnArg, Ident, ImplItemMethod, Meta, ReturnType, TraitItemMethod, Type,
+};
 
 // Unified method info from `ImplItemMethod` and `TraitItemMethod`
 pub struct MethodInfo<'a> {
@@ -57,10 +65,106 @@ pub fn get_arg_props_all<'a>(method: &'a MethodInfo<'a>) -> (Vec<Ident>, Vec<&sy
     get_arg_props(false, method)
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum InterfaceCompilationTarget {
+    R55,
+    EVM,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum InterfaceNamingStyle {
+    CamelCase,
+}
+
+pub struct InterfaceArgs {
+    pub target: InterfaceCompilationTarget,
+    pub rename: Option<InterfaceNamingStyle>,
+}
+
+impl Parse for InterfaceArgs {
+    fn parse(input: ParseStream) -> Result<Self, syn::Error> {
+        // default arg values if uninformed
+        let mut target = InterfaceCompilationTarget::R55;
+        let mut rename_style = None;
+
+        // Parse all attributes
+        let mut first = true;
+        while !input.is_empty() {
+            if !first {
+                input.parse::<syn::Token![,]>()?;
+            }
+            first = false;
+
+            let key: syn::Ident = input.parse()?;
+
+            match key.to_string().as_str() {
+                "rename" => {
+                    input.parse::<syn::Token![=]>()?;
+
+                    // Handle both string literals and identifiers
+                    let value = if input.peek(syn::LitStr) {
+                        let lit: syn::LitStr = input.parse()?;
+                        lit.value()
+                    } else {
+                        let ident: syn::Ident = input.parse()?;
+                        ident.to_string()
+                    };
+
+                    rename_style = Some(match value.as_str() {
+                        "camelCase" => InterfaceNamingStyle::CamelCase,
+                        invalid => {
+                            return Err(syn::Error::new(
+                                key.span(),
+                                format!("unsupported rename style: {}", invalid),
+                            ))
+                        }
+                    });
+                }
+                "target" => {
+                    input.parse::<syn::Token![=]>()?;
+
+                    // Handle both string literals and identifiers
+                    let value = if input.peek(syn::LitStr) {
+                        let lit: syn::LitStr = input.parse()?;
+                        lit.value()
+                    } else {
+                        let ident: syn::Ident = input.parse()?;
+                        ident.to_string()
+                    };
+
+                    target = match value.as_str() {
+                        "r55" => InterfaceCompilationTarget::R55,
+                        "evm" => InterfaceCompilationTarget::EVM,
+                        invalid => {
+                            return Err(syn::Error::new(
+                                key.span(),
+                                format!("unsupported compilation target: {}", invalid),
+                            ))
+                        }
+                    };
+                }
+                invalid => {
+                    return Err(syn::Error::new(
+                        key.span(),
+                        format!("unknown attribute: {}", invalid),
+                    ))
+                }
+            }
+        }
+
+        Ok(InterfaceArgs {
+            target,
+            rename: rename_style,
+        })
+    }
+}
+
 // Helper function to generate interface impl from user-defined methods
 pub fn generate_interface<T>(
     methods: &[&T],
     interface_name: &Ident,
+    interface_style: Option<InterfaceNamingStyle>,
+    interface_target: InterfaceCompilationTarget,
 ) -> quote::__private::TokenStream
 where
     for<'a> MethodInfo<'a>: From<&'a T>,
@@ -71,11 +175,14 @@ where
     let method_impls = methods.iter().map(|method| {
         let name = method.name;
         let return_type = method.return_type;
-        let method_selector = u32::from_be_bytes(
-            keccak256(name.to_string())[..4]
-                .try_into()
-                .unwrap_or_default(),
-        );
+        let method_selector = match interface_target {
+            InterfaceCompilationTarget::R55 => u32::from_be_bytes(
+                generate_selector_r55(method, interface_style).expect("Unable to generate r55 fn selector"),
+            ),
+            InterfaceCompilationTarget::EVM => u32::from_be_bytes(
+                generate_selector_evm(method, interface_style).expect("Unable to generate evm fn selector"),
+            ),
+        };
 
         let (arg_names, arg_types) = get_arg_props_skip_first(method);
 
@@ -119,7 +226,7 @@ where
                     self.address,
                     0_u64,
                     &complete_calldata,
-                    32_u64
+                    None
                 )?;
 
                 <#return_ty>::abi_decode(&result, true).ok()
@@ -142,6 +249,168 @@ where
     }
 }
 
+// Helper function to generate fn selector for r55 contracts
+pub fn generate_selector_r55(method: &MethodInfo, style: Option<InterfaceNamingStyle>) -> Option<[u8; 4]> {
+    let name = match style {
+        None => method.name.to_string(),
+        Some(style) => match style {
+            InterfaceNamingStyle::CamelCase => to_camel_case(method.name.to_string()),
+        }
+    };
+    keccak256(name)[..4].try_into().ok()
+}
+
+// Helper function to generate fn selector for evm contracts
+pub fn generate_selector_evm(method: &MethodInfo, style: Option<InterfaceNamingStyle>) -> Option<[u8; 4]> {
+    let name = match style {
+        None => method.name.to_string(),
+        Some(style) => match style {
+            InterfaceNamingStyle::CamelCase => to_camel_case(method.name.to_string()),
+        }
+    };
+
+    let (_, arg_types) = get_arg_props_skip_first(method);
+    let args = arg_types
+        .iter()
+        .map(|ty| rust_type_to_sol_type(ty))
+        .collect::<Result<Vec<_>, _>>()
+        .ok()?;
+    let args_str = args
+        .iter()
+        .map(|ty| ty.sol_type_name().into_owned())
+        .collect::<Vec<_>>()
+        .join(",");
+
+    let selector = format!("{}({})", name, args_str);
+    keccak256(selector)[..4].try_into().ok()
+}
+
+// Helper function to convert rust types to their solidity equivalent
+// TODO: make sure that the impl is robust, so far only tested with "simple types"
+fn rust_type_to_sol_type(ty: &Type) -> Result<DynSolType, &'static str> {
+    match ty {
+        Type::Path(type_path) => {
+            let path = &type_path.path;
+            let segment = path.segments.last().ok_or("Empty type path")?;
+            let ident = &segment.ident;
+            let type_name = ident.to_string();
+
+            match type_name.as_str() {
+                // Fixed-size types
+                "Address" => Ok(DynSolType::Address),
+                "Function" => Ok(DynSolType::Function),
+                "bool" | "Bool" => Ok(DynSolType::Bool),
+                "String" | "str" => Ok(DynSolType::String),
+                "Bytes" => Ok(DynSolType::Bytes),
+                // Fixed-size bytes
+                b if b.starts_with('B') => {
+                    let size: usize = b
+                        .trim_start_matches('B')
+                        .parse()
+                        .map_err(|_| "Invalid fixed bytes size")?;
+                    if size > 0 && size <= 32 {
+                        Ok(DynSolType::FixedBytes(size))
+                    } else {
+                        Err("Invalid fixed bytes size (between 1-32)")
+                    }
+                }
+                // Fixed-size unsigned integers
+                u if u.starts_with('U') => {
+                    let size: usize = u
+                        .trim_start_matches('U')
+                        .parse()
+                        .map_err(|_| "Invalid uint size")?;
+                    if size > 0 && size <= 256 && size % 8 == 0 {
+                        Ok(DynSolType::Uint(size))
+                    } else {
+                        Err("Invalid uint size (multiple of 8 + leq 256)")
+                    }
+                }
+                // Fixed-size signed integers
+                i if i.starts_with('I') => {
+                    let size: usize = i
+                        .trim_start_matches('I')
+                        .parse()
+                        .map_err(|_| "Invalid int size")?;
+                    if size > 0 && size <= 256 && size % 8 == 0 {
+                        Ok(DynSolType::Int(size))
+                    } else {
+                        Err("Invalid int size (must be multiple of 8, max 256)")
+                    }
+                }
+                // Handle vecs
+                _ => {
+                    if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
+                        match type_name.as_str() {
+                            "Vec" => {
+                                let inner = args.args.first().ok_or("Empty Vec type argument")?;
+                                if let syn::GenericArgument::Type(inner_ty) = inner {
+                                    let inner_sol_type = rust_type_to_sol_type(inner_ty)?;
+                                    Ok(DynSolType::Array(Box::new(inner_sol_type)))
+                                } else {
+                                    Err("Invalid Vec type argument")
+                                }
+                            }
+                            _ => Err("Unsupported generic type"),
+                        }
+                    } else {
+                        Err("Unsupported type")
+                    }
+                }
+            }
+        }
+        Type::Array(array) => {
+            let inner_sol_type = rust_type_to_sol_type(&array.elem)?;
+            if let syn::Expr::Lit(lit) = &array.len {
+                if let syn::Lit::Int(size) = &lit.lit {
+                    let size: usize = size
+                        .base10_digits()
+                        .parse()
+                        .map_err(|_| "Invalid array size")?;
+                    Ok(DynSolType::FixedArray(Box::new(inner_sol_type), size))
+                } else {
+                    Err("Invalid array size literal")
+                }
+            } else {
+                Err("Invalid array size expression")
+            }
+        }
+        Type::Tuple(tuple) => {
+            let inner_types = tuple
+                .elems
+                .iter()
+                .map(rust_type_to_sol_type)
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(DynSolType::Tuple(inner_types))
+        }
+        _ => Err("Unsupported type"),
+    }
+}
+
+fn to_camel_case(s: String) -> String {
+    let mut result = String::new();
+    let mut capitalize_next = false;
+
+    // Iterate through characters, skipping non-alphabetic separators
+    for (i, c) in s.chars().enumerate() {
+        if c.is_alphanumeric() {
+            if i == 0 {
+                result.push(c.to_ascii_lowercase());
+            } else if capitalize_next {
+                result.push(c.to_ascii_uppercase());
+                capitalize_next = false;
+            } else {
+                result.push(c);
+            }
+        } else {
+            // Set flag to capitalize next char  with non-alphanumeric ones
+            capitalize_next = true;
+        }
+    }
+
+    result
+}
+
 // Helper function to generate the deployment code
 pub fn generate_deployment_code(
     struct_name: &Ident,

contract-derive/src/lib.rs

@@ -4,12 +4,11 @@ use alloy_sol_types::SolValue;
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 use syn::{
-    parse_macro_input, Data, DeriveInput, Fields, ImplItem, ImplItemMethod, ItemImpl, ItemTrait,
-    ReturnType, TraitItem,
+    parse_macro_input, spanned::Spanned, Data, DeriveInput, Fields, ImplItem, ImplItemMethod, ItemImpl, ItemTrait, LitStr, Meta, NestedMeta, ReturnType, TraitItem
 };
 
 mod helpers;
-use crate::helpers::MethodInfo;
+use crate::helpers::{MethodInfo, InterfaceCompilationTarget, InterfaceArgs};
 
 #[proc_macro_derive(Event, attributes(indexed))]
 pub fn event_derive(input: TokenStream) -> TokenStream {
@@ -226,7 +225,7 @@ pub fn contract(_attr: TokenStream, item: TokenStream) -> TokenStream {
 
     // Generate the interface
     let interface_name = format_ident!("I{}", struct_name);
-    let interface = helpers::generate_interface(&public_methods, &interface_name);
+    let interface = helpers::generate_interface(&public_methods, &interface_name, None, InterfaceCompilationTarget::R55);
 
     // Generate initcode for deployments
     let deployment_code = helpers::generate_deployment_code(struct_name, constructor);
@@ -326,8 +325,9 @@ fn is_payable(method: &syn::ImplItemMethod) -> bool {
 }
 
 #[proc_macro_attribute]
-pub fn interface(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub fn interface(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as ItemTrait);
+    let args = parse_macro_input!(attr as InterfaceArgs);
     let trait_name = &input.ident;
 
     let methods: Vec<_> = input
@@ -343,7 +343,7 @@ pub fn interface(_attr: TokenStream, item: TokenStream) -> TokenStream {
         .collect();
 
     // Generate intreface implementation
-    let interface = helpers::generate_interface(&methods, trait_name);
+    let interface = helpers::generate_interface(&methods, trait_name, args.rename, args.target);
 
     let output = quote! {
         #interface