git.delta.rocks / unique-network / refs/commits / 0a660b904e66

--- /dev/null
+++ b/crates/evm-coder-macros/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "evm-coder-macros"
+version = "0.1.0"
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+sha3 = "0.9.1"
+quote = "1.0"
+proc-macro2 = "1.0"
+syn = { version = "1.0", features = ["full"] }
+hex = "0.4.3"
+Inflector = "0.11.4"
+darling = "0.13.0"
\ No newline at end of file

--- /dev/null
+++ b/crates/evm-coder-macros/src/lib.rs
@@ -0,0 +1,224 @@
+use darling::FromMeta;
+use inflector::cases;
+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,
+};
+
+mod solidity_interface;
+mod to_log;
+
+fn fn_selector_str(input: &str) -> u32 {
+	let mut hasher = Keccak256::new();
+	hasher.update(input.as_bytes());
+	let result = hasher.finalize();
+
+	let mut selector_bytes = [0; 4];
+	selector_bytes.copy_from_slice(&result[0..4]);
+
+	u32::from_be_bytes(selector_bytes)
+}
+
+/// Returns solidity function selector (first 4 bytes of hash) by its
+/// textual representation
+///
+/// ```rs
+/// use evm_coder_macros::fn_selector;
+///
+/// assert_eq!(fn_selector!(transfer(address, uint256)), 0xa9059cbb);
+/// ```
+#[proc_macro]
+pub fn fn_selector(input: TokenStream) -> TokenStream {
+	let input = input.to_string().replace(' ', "");
+	let selector = fn_selector_str(&input);
+
+	(quote! {
+		#selector
+	})
+	.into()
+}
+
+fn event_selector_str(input: &str) -> [u8; 32] {
+	let mut hasher = Keccak256::new();
+	hasher.update(input.as_bytes());
+	let result = hasher.finalize();
+
+	let mut selector_bytes = [0; 32];
+	selector_bytes.copy_from_slice(&result[0..32]);
+	selector_bytes
+}
+
+/// Returns solidity topic (hash) by its textual representation
+///
+/// ```rs
+/// use evm_coder_macros::event_topic;
+///
+/// assert_eq!(
+///     format!("{:x}", event_topic!(Transfer(address, address, uint256))),
+///     "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+/// );
+/// ```
+#[proc_macro]
+pub fn event_topic(stream: TokenStream) -> TokenStream {
+	let input = stream.to_string().replace(' ', "");
+	let selector_bytes = event_selector_str(&input);
+
+	(quote! {
+		::primitive_types::H256([#(
+			#selector_bytes,
+		)*])
+	})
+	.into()
+}
+
+fn parse_path(ty: &Type) -> syn::Result<&Path> {
+	match &ty {
+		syn::Type::Path(pat) => {
+			if let Some(qself) = &pat.qself {
+				return Err(syn::Error::new(qself.ty.span(), "no receiver expected"));
+			}
+			Ok(&pat.path)
+		}
+		_ => Err(syn::Error::new(ty.span(), "expected ty to be path")),
+	}
+}
+
+fn parse_path_segment(path: &Path) -> syn::Result<&PathSegment> {
+	if path.segments.len() != 1 {
+		return Err(syn::Error::new(
+			path.span(),
+			"expected path to have only segment",
+		));
+	}
+	let last_segment = &path.segments.last().unwrap();
+	Ok(last_segment)
+}
+
+fn parse_ident_from_pat(pat: &Pat) -> syn::Result<&Ident> {
+	match pat {
+		Pat::Ident(i) => Ok(&i.ident),
+		_ => Err(syn::Error::new(pat.span(), "expected pat ident")),
+	}
+}
+
+fn parse_ident_from_segment(segment: &PathSegment) -> syn::Result<&Ident> {
+	if segment.arguments != PathArguments::None {
+		return Err(syn::Error::new(
+			segment.arguments.span(),
+			"unexpected generic type",
+		));
+	}
+	Ok(&segment.ident)
+}
+
+fn parse_ident_from_path(path: &Path) -> syn::Result<&Ident> {
+	let segment = parse_path_segment(path)?;
+	parse_ident_from_segment(segment)
+}
+
+fn parse_ident_from_type(ty: &Type) -> syn::Result<&Ident> {
+	let path = parse_path(ty)?;
+	parse_ident_from_path(path)
+}
+
+// Gets T out of Result<T>
+fn parse_result_ok(ty: &Type) -> syn::Result<&Ident> {
+	let path = parse_path(ty)?;
+	let segment = parse_path_segment(path)?;
+
+	if segment.ident != "Result" {
+		return Err(syn::Error::new(
+			ty.span(),
+			"expected Result as return type (no renamed aliases allowed)",
+		));
+	}
+	let args = match &segment.arguments {
+		PathArguments::AngleBracketed(e) => e,
+		_ => {
+			return Err(syn::Error::new(
+				segment.arguments.span(),
+				"missing Result generics",
+			))
+		}
+	};
+
+	let args = &args.args;
+	let arg = args.first().unwrap();
+
+	let ty = match arg {
+		GenericArgument::Type(ty) => ty,
+		_ => {
+			return Err(syn::Error::new(
+				arg.span(),
+				"expected first generic to be type",
+			))
+		}
+	};
+
+	parse_ident_from_type(ty)
+}
+
+fn pascal_ident_to_call(ident: &Ident) -> Ident {
+	let name = format!("{}Call", ident);
+	Ident::new(&name, ident.span())
+}
+fn snake_ident_to_pascal(ident: &Ident) -> Ident {
+	let name = ident.to_string();
+	let name = cases::pascalcase::to_pascal_case(&name);
+	Ident::new(&name, ident.span())
+}
+fn snake_ident_to_screaming(ident: &Ident) -> Ident {
+	let name = ident.to_string();
+	let name = cases::screamingsnakecase::to_screaming_snake_case(&name);
+	Ident::new(&name, ident.span())
+}
+fn pascal_ident_to_snake_call(ident: &Ident) -> Ident {
+	let name = ident.to_string();
+	let name = cases::snakecase::to_snake_case(&name);
+	let name = format!("call_{}", name);
+	Ident::new(&name, ident.span())
+}
+
+fn format_ty(ty: &Ident) -> String {
+	if ty == "string" {
+		format!("{} memory", ty)
+	} else {
+		ty.to_string()
+	}
+}
+
+#[proc_macro_attribute]
+pub fn solidity_interface(args: TokenStream, stream: TokenStream) -> TokenStream {
+	let args = parse_macro_input!(args as AttributeArgs);
+	let args = solidity_interface::InterfaceInfo::from_list(&args).unwrap();
+
+	let input: ItemTrait = match syn::parse(stream) {
+		Ok(t) => t,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	match solidity_interface::SolidityInterface::try_from(args, &input) {
+		Ok(v) => v.expand(),
+		Err(e) => e.to_compile_error(),
+	}
+	.into()
+}
+
+#[proc_macro_attribute]
+pub fn solidity(_args: TokenStream, stream: TokenStream) -> TokenStream {
+	stream
+}
+
+#[proc_macro_derive(ToLog, attributes(indexed))]
+pub fn to_log(value: TokenStream) -> TokenStream {
+	let input = parse_macro_input!(value as DeriveInput);
+
+	match to_log::Events::try_from(&input) {
+		Ok(e) => e.expand(),
+		Err(e) => e.to_compile_error(),
+	}
+	.into()
+}

no changes

--- /dev/null
+++ b/crates/evm-coder-macros/src/to_log.rs
@@ -0,0 +1,170 @@
+use syn::{Data, DeriveInput, Field, Fields, Ident, Variant, spanned::Spanned};
+use std::fmt::Write;
+use quote::quote;
+
+use crate::{parse_ident_from_path, parse_ident_from_type, snake_ident_to_screaming};
+
+struct EventField {
+	name: Ident,
+	ty: Ident,
+	indexed: bool,
+}
+
+impl EventField {
+	fn try_from(field: &Field) -> syn::Result<Self> {
+		let name = field.ident.as_ref().unwrap();
+		let ty = parse_ident_from_type(&field.ty)?;
+		let mut indexed = false;
+		for attr in &field.attrs {
+			if let Ok(ident) = parse_ident_from_path(&attr.path) {
+				if ident == "indexed" {
+					indexed = true;
+				}
+			}
+		}
+		Ok(Self {
+			name: name.to_owned(),
+			ty: ty.to_owned(),
+			indexed,
+		})
+	}
+}
+
+struct Event {
+	name: Ident,
+	name_screaming: Ident,
+	fields: Vec<EventField>,
+	selector: [u8; 32],
+	selector_str: String,
+}
+
+impl Event {
+	fn try_from(variant: &Variant) -> syn::Result<Self> {
+		let name = &variant.ident;
+		let name_screaming = snake_ident_to_screaming(&name);
+
+		let named = match &variant.fields {
+			Fields::Named(named) => named,
+			_ => {
+				return Err(syn::Error::new(
+					variant.fields.span(),
+					"expected named fields",
+				))
+			}
+		};
+		let mut fields = Vec::new();
+		for field in &named.named {
+			fields.push(EventField::try_from(&field)?);
+		}
+		let mut selector_str = format!("{}(", name);
+		for (i, arg) in fields.iter().enumerate() {
+			if i != 0 {
+				write!(selector_str, ",").unwrap();
+			}
+			write!(selector_str, "{}", arg.ty).unwrap();
+		}
+		selector_str.push(')');
+		let selector = crate::event_selector_str(&selector_str);
+
+		Ok(Self {
+			name: name.to_owned(),
+			name_screaming,
+			fields,
+			selector,
+			selector_str,
+		})
+	}
+
+	fn expand_serializers(&self) -> proc_macro2::TokenStream {
+		let name = &self.name;
+		let name_screaming = &self.name_screaming;
+		let fields = self.fields.iter().map(|f| &f.name);
+
+		let indexed = self.fields.iter().filter(|f| f.indexed).map(|f| &f.name);
+		let plain = self.fields.iter().filter(|f| !f.indexed).map(|f| &f.name);
+
+		quote! {
+			Self::#name {#(
+				#fields,
+			)*} => {
+				topics.push(topic::from(Self::#name_screaming));
+				#(
+					topics.push(#indexed.to_topic());
+				)*
+				#(
+					#plain.abi_write(&mut writer);
+				)*
+			}
+		}
+	}
+
+	fn expand_consts(&self) -> proc_macro2::TokenStream {
+		let name_screaming = &self.name_screaming;
+		let selector_str = &self.selector_str;
+		let selector = &self.selector;
+
+		quote! {
+			#[doc = #selector_str]
+			const #name_screaming: [u8; 32] = [#(
+				#selector,
+			)*];
+		}
+	}
+}
+
+pub struct Events {
+	name: Ident,
+	events: Vec<Event>,
+}
+
+impl Events {
+	pub fn try_from(data: &DeriveInput) -> syn::Result<Self> {
+		let name = &data.ident;
+		let en = match &data.data {
+			Data::Enum(en) => en,
+			_ => return Err(syn::Error::new(data.span(), "expected enum")),
+		};
+		let mut events = Vec::new();
+		for variant in &en.variants {
+			events.push(Event::try_from(variant)?);
+		}
+		Ok(Self {
+			name: name.to_owned(),
+			events,
+		})
+	}
+	pub fn expand(&self) -> proc_macro2::TokenStream {
+		let name = &self.name;
+
+		let consts = self.events.iter().map(Event::expand_consts);
+		let serializers = self.events.iter().map(Event::expand_serializers);
+
+		quote! {
+			impl #name {
+				#(
+					#consts
+				)*
+			}
+
+			#[automatically_derived]
+			impl ::evm_coder::events::ToLog for #name {
+				fn to_log(&self, contract: address) -> ::ethereum::Log {
+					use ::evm_coder::events::ToTopic;
+					use ::evm_coder::abi::AbiWrite;
+					let mut writer = ::evm_coder::abi::AbiWriter::new();
+					let mut topics = Vec::new();
+					match self {
+						#(
+							#serializers,
+						)*
+					}
+					::ethereum::Log {
+						address: contract,
+						topics,
+						data: writer.finish(),
+					}
+				}
+			}
+		}
+	}
+}