From 5a3fe2c70832c174ddb79e64f3502eb2ba2557fb Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Wed, 02 Nov 2022 15:45:23 +0000 Subject: [PATCH] refactor: unify function and type signature handling --- --- a/crates/evm-coder/procedural/src/solidity_interface.rs +++ b/crates/evm-coder/procedural/src/solidity_interface.rs @@ -24,8 +24,8 @@ use quote::{quote, format_ident}; use inflector::cases; use syn::{ - Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta, - MetaNameValue, PatType, PathArguments, ReturnType, Type, + Expr, FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta, MetaNameValue, + PatType, ReturnType, Type, spanned::Spanned, parse::{Parse, ParseStream}, parenthesized, Token, LitInt, LitStr, @@ -601,12 +601,12 @@ let screaming_name_signature = format_ident!("{}_SIGNATURE", &self.screaming_name); let custom_signature = self.expand_custom_signature(); quote! { - const #screaming_name_signature: ::evm_coder::custom_signature::FunctionSignature = #custom_signature; + const #screaming_name_signature: ::evm_coder::custom_signature::SignatureUnit = #custom_signature; const #screaming_name: ::evm_coder::types::bytes4 = { let mut sum = ::evm_coder::sha3_const::Keccak256::new(); let mut pos = 0; - while pos < Self::#screaming_name_signature.unit.len { - sum = sum.update(&[Self::#screaming_name_signature.unit.data[pos]; 1]); + while pos < Self::#screaming_name_signature.len { + sum = sum.update(&[Self::#screaming_name_signature.data[pos]; 1]); pos += 1; } let a = sum.finalize(); @@ -710,192 +710,28 @@ }; quote! { Self::#pascal_name #matcher => ().into() - } - } - } - - fn expand_type(ty: &Type, token_stream: &mut proc_macro2::TokenStream, read_signature: bool) { - match ty { - Type::Path(tp) => { - if let Some(qself) = &tp.qself { - panic!("no receiver expected {:?}", qself.ty.span()); - } - let path = &tp.path; - if path.segments.len() != 1 { - panic!("expected path to have only one segment {:?}", path.span()); - } - let last_segment = path.segments.last().unwrap(); - - if last_segment.ident == "Vec" { - let args = match &last_segment.arguments { - PathArguments::AngleBracketed(e) => e, - _ => { - panic!("missing Vec generic {:?}", last_segment.arguments.span()); - } - }; - let args = &args.args; - if args.len() != 1 { - panic!("expected only one generic for vec {:?}", args.span()); - } - let arg = args.first().expect("first arg"); - - let ty = match arg { - GenericArgument::Type(ty) => ty, - _ => { - panic!("expected first generic to be type {:?}", arg.span()); - } - }; - - let mut vec_token = proc_macro2::TokenStream::new(); - Self::expand_type(ty, &mut vec_token, false); - vec_token = if read_signature { - quote! { (>::SIGNATURE) } - } else { - quote! { > } - }; - token_stream.extend(vec_token); - } else { - if !last_segment.arguments.is_empty() { - panic!( - "unexpected generic arguments for non-vec type {:?}", - last_segment.arguments.span() - ); - } - - let ident = &last_segment.ident; - let plain_token = if read_signature { - quote! { - (<#ident>::SIGNATURE) - } - } else { - quote! { - #ident - } - }; - - token_stream.extend(plain_token); - } - } - - Type::Tuple(tt) => { - // for ty in tt.elems.iter() { - // out.push(AbiType::try_from(ty)?) - // } - - let mut tuple_types = proc_macro2::TokenStream::new(); - let mut is_first = true; - - for ty in tt.elems.iter() { - if is_first { - is_first = false - } else { - tuple_types.extend(quote!(,)); - } - Self::expand_type(ty, &mut tuple_types, false); - } - tuple_types = if read_signature { - quote! { (<(#tuple_types)>::SIGNATURE) } - } else { - quote! { (#tuple_types) } - }; - token_stream.extend(tuple_types); } - - // Type::Array(arr) => { - // let wrapped = AbiType::try_from(&arr.elem)?; - // match &arr.len { - // Expr::Lit(l) => match &l.lit { - // Lit::Int(i) => { - // let num = i.base10_parse::()?; - // Ok(AbiType::Array(Box::new(wrapped), num as usize)) - // } - // _ => Err(syn::Error::new(arr.len.span(), "should be int literal")), - // }, - // _ => Err(syn::Error::new(arr.len.span(), "should be literal")), - // } - // } - _ => panic!("Unexpected type {ty:?}"), } - // match ty { - // AbiType::Plain(ref ident) => { - // let plain_token = if read_signature { - // quote! { - // (<#ident>::SIGNATURE) - // } - // } else { - // quote! { - // #ident - // } - // }; - - // token_stream.extend(plain_token); - // } - - // AbiType::Tuple(ref tuple_type) => { - // let mut tuple_types = proc_macro2::TokenStream::new(); - // let mut is_first = true; - - // for ty in tuple_type { - // if is_first { - // is_first = false - // } else { - // tuple_types.extend(quote!(,)); - // } - // Self::expand_type(ty, &mut tuple_types, false); - // } - // tuple_types = if read_signature { - // quote! { (<(#tuple_types)>::SIGNATURE) } - // } else { - // quote! { (#tuple_types) } - // }; - // token_stream.extend(tuple_types); - // } - - // AbiType::Vec(ref vec_type) => { - // let mut vec_token = proc_macro2::TokenStream::new(); - // Self::expand_type(vec_type.as_ref(), &mut vec_token, false); - // vec_token = if read_signature { - // quote! { (>::SIGNATURE) } - // } else { - // quote! { > } - // }; - // token_stream.extend(vec_token); - // } - - // AbiType::Array(_, _) => todo!("Array eth signature"), - // }; } fn expand_custom_signature(&self) -> proc_macro2::TokenStream { - let mut token_stream = TokenStream::new(); + let mut args = TokenStream::new(); let mut is_first = true; - for arg in &self.args { - if arg.is_special() { - continue; - } - - if is_first { - is_first = false; - } else { - token_stream.extend(quote!(,)); - } - Self::expand_type(&arg.ty, &mut token_stream, true); + for arg in self.args.iter().filter(|a| !a.is_special()) { + is_first = false; + let ty = &arg.ty; + args.extend(quote! {nameof(#ty)}); + args.extend(quote! {fixed(",")}) } + // Remove trailing comma if !is_first { - token_stream.extend(quote!(,)); + args.extend(quote! {shift_left(1)}) } let func_name = self.camel_name.clone(); - let func_name = quote!(SignaturePreferences { - open_name: Some(SignatureUnit::new(#func_name)), - open_delimiter: Some(SignatureUnit::new("(")), - param_delimiter: Some(SignatureUnit::new(",")), - close_delimiter: Some(SignatureUnit::new(")")), - close_name: None, - }); - quote!({ ::evm_coder::make_signature!(new fn(#func_name), #token_stream) }) + quote! { ::evm_coder::make_signature!(new fixed(#func_name) fixed("(") #args fixed(")")) } } fn expand_solidity_function(&self) -> proc_macro2::TokenStream { @@ -916,12 +752,6 @@ let screaming_name = &self.screaming_name; let hide = self.hide; let custom_signature = self.expand_custom_signature(); - let custom_signature = quote!( - { - const cs: FunctionSignature = #custom_signature; - cs - } - ); let is_payable = self.has_value_args; quote! { --- a/crates/evm-coder/src/abi.rs +++ b/crates/evm-coder/src/abi.rs @@ -27,7 +27,7 @@ execution::{Error, ResultWithPostInfo, WithPostDispatchInfo}, types::*, make_signature, - custom_signature::{SignatureUnit, SIGNATURE_SIZE_LIMIT}, + custom_signature::{SignatureUnit}, }; use crate::execution::Result; @@ -428,7 +428,7 @@ } impl Signature for Vec { - make_signature!(new nameof(R) fixed("[]")); + const SIGNATURE: SignatureUnit = make_signature!(new nameof(R) fixed("[]")); } impl sealed::CanBePlacedInVec for EthCrossAccount {} @@ -522,7 +522,7 @@ where $($ident: Signature,)+ { - make_signature!( + const SIGNATURE: SignatureUnit = make_signature!( new fixed("(") $(nameof($ident) fixed(","))+ shift_left(1) @@ -758,13 +758,13 @@ 1ACF2D55 0000000000000000000000000000000000000000000000000000000000000020 // offset of (address, uint256)[] 0000000000000000000000000000000000000000000000000000000000000003 // length of (address, uint256)[] - + 0000000000000000000000002D2FF76104B7BACB2E8F6731D5BFC184EBECDDBC // address 000000000000000000000000000000000000000000000000000000000000000A // uint256 - + 000000000000000000000000AB8E3D9134955566483B11E6825C9223B6737B10 // address 0000000000000000000000000000000000000000000000000000000000000014 // uint256 - + 0000000000000000000000008C582BDF2953046705FC56F189385255EFC1BE18 // address 000000000000000000000000000000000000000000000000000000000000001E // uint256 " --- a/crates/evm-coder/src/custom_signature.rs +++ b/crates/evm-coder/src/custom_signature.rs @@ -74,132 +74,11 @@ //! impl SoliditySignature for Vec { //! make_signature!(new nameof(T) fixed("[]")); //! } -//! -//! // Function signature settings -//! const SIGNATURE_PREFERENCES: SignaturePreferences = SignaturePreferences { -//! open_name: Some(SignatureUnit::new("some_funk")), -//! open_delimiter: Some(SignatureUnit::new("(")), -//! param_delimiter: Some(SignatureUnit::new(",")), -//! close_delimiter: Some(SignatureUnit::new(")")), -//! close_name: None, -//! }; -//! -//! // Create functions signatures -//! fn make_func_without_args() { -//! const SIG: FunctionSignature = make_signature!( -//! new fn(SIGNATURE_PREFERENCES), -//! ); -//! let name = SIG.as_str(); -//! similar_asserts::assert_eq!(name, "some_funk()"); -//! } -//! -//! fn make_func_with_3_args() { -//! const SIG: FunctionSignature = make_signature!( -//! new fn(SIGNATURE_PREFERENCES), -//! (::SIGNATURE), -//! (::SIGNATURE), -//! (>::SIGNATURE), -//! ); -//! let name = SIG.as_str(); -//! similar_asserts::assert_eq!(name, "some_funk(uint8,uint8,uint8[])"); -//! } //! ``` -use core::str::from_utf8; /// The maximum length of the signature. pub const SIGNATURE_SIZE_LIMIT: usize = 256; - -/// Function signature formatting preferences. -#[derive(Debug)] -pub struct SignaturePreferences { - /// The name of the function before the list of parameters: `*some*(param1,param2)func` - pub open_name: Option, - /// Opening separator: `some*(*param1,param2)func` - pub open_delimiter: Option, - /// Parameters separator: `some(param1*,*param2)func` - pub param_delimiter: Option, - /// Closinging separator: `some(param1,param2*)*func` - pub close_delimiter: Option, - /// The name of the function after the list of parameters: `some(param1,param2)*func*` - pub close_name: Option, -} - -/// Constructs and stores the signature of the function. -#[derive(Debug)] -pub struct FunctionSignature { - /// Storage for function signature. - pub unit: SignatureUnit, - preferences: SignaturePreferences, -} -impl FunctionSignature { - /// Start constructing the signature. It is written to the storage - /// [`SignaturePreferences::open_name`] and [`SignaturePreferences::open_delimiter`]. - pub const fn new(preferences: SignaturePreferences) -> FunctionSignature { - let mut dst = [0_u8; SIGNATURE_SIZE_LIMIT]; - let mut dst_offset = 0; - if let Some(ref name) = preferences.open_name { - crate::make_signature!(@copy(name.data, dst, name.len, dst_offset)); - } - if let Some(ref delimiter) = preferences.open_delimiter { - crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset)); - } - FunctionSignature { - unit: SignatureUnit { - data: dst, - len: dst_offset, - }, - preferences, - } - } - - /// Add a function parameter to the signature. It is written to the storage - /// `param` [`SignatureUnit`] and [`SignaturePreferences::param_delimiter`]. - pub const fn add_param( - signature: FunctionSignature, - param: SignatureUnit, - ) -> FunctionSignature { - let mut dst = signature.unit.data; - let mut dst_offset = signature.unit.len; - crate::make_signature!(@copy(param.data, dst, param.len, dst_offset)); - if let Some(ref delimiter) = signature.preferences.param_delimiter { - crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset)); - } - FunctionSignature { - unit: SignatureUnit { - data: dst, - len: dst_offset, - }, - ..signature - } - } - - /// Complete signature construction. It is written to the storage - /// [`SignaturePreferences::close_delimiter`] and [`SignaturePreferences::close_name`]. - pub const fn done(signature: FunctionSignature, owerride: bool) -> FunctionSignature { - let mut dst = signature.unit.data; - let mut dst_offset = signature.unit.len - if owerride { 1 } else { 0 }; - if let Some(ref delimiter) = signature.preferences.close_delimiter { - crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset)); - } - if let Some(ref name) = signature.preferences.close_name { - crate::make_signature!(@copy(name.data, dst, name.len, dst_offset)); - } - FunctionSignature { - unit: SignatureUnit { - data: dst, - len: dst_offset, - }, - ..signature - } - } - - /// Represent the signature as `&str'. - pub fn as_str(&self) -> &str { - from_utf8(&self.unit.data[..self.unit.len]).expect("bad utf-8") - } -} - /// Storage for the signature or its elements. #[derive(Debug)] pub struct SignatureUnit { @@ -222,6 +101,10 @@ len: name_len, } } + /// String conversion + pub fn as_str(&self) -> Option<&str> { + core::str::from_utf8(&self.data[0..self.len]).ok() + } } /// ### Macro to create signatures of types and functions. @@ -231,85 +114,52 @@ /// make_signature!(new fixed("uint8")); // Simple type /// make_signature!(new fixed("(") nameof(u8) fixed(",") nameof(u8) fixed(")")); // Composite type /// ``` -/// Format for creating a function of the function: -/// ```ignore -/// const SIG: FunctionSignature = make_signature!( -/// new fn(SIGNATURE_PREFERENCES), -/// (u8::SIGNATURE), -/// (<(u8,u8)>::SIGNATURE), -/// ); -/// ``` #[macro_export] macro_rules! make_signature { - (new fn($func:expr)$(,)*) => { - { - let fs = FunctionSignature::new($func); - let fs = FunctionSignature::done(fs, false); - fs - } - }; - (new fn($func:expr), $($tt:tt,)*) => { - { - let fs = FunctionSignature::new($func); - let fs = make_signature!(@param; fs, $($tt),*); - fs - } + (new $($tt:tt)*) => { + ($crate::custom_signature::SignatureUnit { + data: { + let mut out = [0u8; $crate::custom_signature::SIGNATURE_SIZE_LIMIT]; + let mut dst_offset = 0; + $crate::make_signature!(@data(out, dst_offset); $($tt)*); + out + }, + len: {0 + $crate::make_signature!(@size; $($tt)*)}, + }) }; - (@param; $func:expr) => { - FunctionSignature::done($func, true) + (@size;) => { + 0 }; - (@param; $func:expr, $param:expr) => { - make_signature!(@param; FunctionSignature::add_param($func, $param)) + (@size; fixed($expr:expr) $($tt:tt)*) => { + $expr.len() + $crate::make_signature!(@size; $($tt)*) }; - (@param; $func:expr, $param:expr, $($tt:tt),*) => { - make_signature!(@param; FunctionSignature::add_param($func, $param), $($tt),*) + (@size; nameof($expr:ty) $($tt:tt)*) => { + <$expr>::SIGNATURE.len + $crate::make_signature!(@size; $($tt)*) }; - - (new $($tt:tt)*) => { - const SIGNATURE: SignatureUnit = SignatureUnit { - data: { - let mut out = [0u8; SIGNATURE_SIZE_LIMIT]; - let mut dst_offset = 0; - make_signature!(@data(out, dst_offset); $($tt)*); - out - }, - len: {0 + make_signature!(@size; $($tt)*)}, - }; - }; - - (@size;) => { - 0 - }; - (@size; fixed($expr:expr) $($tt:tt)*) => { - $expr.len() + make_signature!(@size; $($tt)*) - }; - (@size; nameof($expr:ty) $($tt:tt)*) => { - <$expr>::SIGNATURE.len + make_signature!(@size; $($tt)*) - }; (@size; shift_left($expr:expr) $($tt:tt)*) => { - make_signature!(@size; $($tt)*) - $expr + $crate::make_signature!(@size; $($tt)*) - $expr }; - (@data($dst:ident, $dst_offset:ident);) => {}; - (@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => { - { - let data = $expr.as_bytes(); + (@data($dst:ident, $dst_offset:ident);) => {}; + (@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => { + { + let data = $expr.as_bytes(); let data_len = data.len(); - make_signature!(@copy(data, $dst, data_len, $dst_offset)); - } - make_signature!(@data($dst, $dst_offset); $($tt)*) - }; - (@data($dst:ident, $dst_offset:ident); nameof($expr:ty) $($tt:tt)*) => { - { - make_signature!(@copy(&<$expr>::SIGNATURE.data, $dst, <$expr>::SIGNATURE.len, $dst_offset)); - } - make_signature!(@data($dst, $dst_offset); $($tt)*) - }; + $crate::make_signature!(@copy(data, $dst, data_len, $dst_offset)); + } + $crate::make_signature!(@data($dst, $dst_offset); $($tt)*) + }; + (@data($dst:ident, $dst_offset:ident); nameof($expr:ty) $($tt:tt)*) => { + { + $crate::make_signature!(@copy(&<$expr>::SIGNATURE.data, $dst, <$expr>::SIGNATURE.len, $dst_offset)); + } + $crate::make_signature!(@data($dst, $dst_offset); $($tt)*) + }; (@data($dst:ident, $dst_offset:ident); shift_left($expr:expr) $($tt:tt)*) => { - $dst_offset -= $expr; - make_signature!(@data($dst, $dst_offset); $($tt)*) - }; + $dst_offset -= $expr; + $crate::make_signature!(@data($dst, $dst_offset); $($tt)*) + }; (@copy($src:expr, $dst:expr, $src_len:expr, $dst_offset:ident)) => { { @@ -328,7 +178,7 @@ mod test { use core::str::from_utf8; - use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit, FunctionSignature, SignaturePreferences}; + use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit}; trait Name { const SIGNATURE: SignatureUnit; @@ -339,19 +189,21 @@ } impl Name for u8 { - make_signature!(new fixed("uint8")); + const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8")); } impl Name for u32 { - make_signature!(new fixed("uint32")); + const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint32")); } impl Name for Vec { - make_signature!(new nameof(T) fixed("[]")); + const SIGNATURE: SignatureUnit = make_signature!(new nameof(T) fixed("[]")); } impl Name for (A, B) { - make_signature!(new fixed("(") nameof(A) fixed(",") nameof(B) fixed(")")); + const SIGNATURE: SignatureUnit = + make_signature!(new fixed("(") nameof(A) fixed(",") nameof(B) fixed(")")); } impl Name for (A,) { - make_signature!(new fixed("(") nameof(A) fixed(",") shift_left(1) fixed(")")); + const SIGNATURE: SignatureUnit = + make_signature!(new fixed("(") nameof(A) fixed(",") shift_left(1) fixed(")")); } struct MaxSize(); @@ -361,14 +213,6 @@ len: SIGNATURE_SIZE_LIMIT, }; } - - const SIGNATURE_PREFERENCES: SignaturePreferences = SignaturePreferences { - open_name: Some(SignatureUnit::new("some_funk")), - open_delimiter: Some(SignatureUnit::new("(")), - param_delimiter: Some(SignatureUnit::new(",")), - close_delimiter: Some(SignatureUnit::new(")")), - close_name: None, - }; #[test] fn simple() { @@ -421,68 +265,6 @@ #[test] fn max_size() { assert_eq!(::name(), "!".repeat(SIGNATURE_SIZE_LIMIT)); - } - - #[test] - fn make_func_without_args() { - const SIG: FunctionSignature = make_signature!( - new fn(SIGNATURE_PREFERENCES) - ); - let name = SIG.as_str(); - similar_asserts::assert_eq!(name, "some_funk()"); - } - - #[test] - fn make_func_with_1_args() { - const SIG: FunctionSignature = make_signature!( - new fn(SIGNATURE_PREFERENCES), - (::SIGNATURE), - ); - let name = SIG.as_str(); - similar_asserts::assert_eq!(name, "some_funk(uint8)"); - } - - #[test] - fn make_func_with_2_args() { - const SIG: FunctionSignature = make_signature!( - new fn(SIGNATURE_PREFERENCES), - (u8::SIGNATURE), - (>::SIGNATURE), - ); - let name = SIG.as_str(); - similar_asserts::assert_eq!(name, "some_funk(uint8,uint32[])"); - } - - #[test] - fn make_func_with_3_args() { - const SIG: FunctionSignature = make_signature!( - new fn(SIGNATURE_PREFERENCES), - (::SIGNATURE), - (::SIGNATURE), - (>::SIGNATURE), - ); - let name = SIG.as_str(); - similar_asserts::assert_eq!(name, "some_funk(uint8,uint32,uint32[])"); - } - - #[test] - fn make_slice_from_signature() { - const SIG: FunctionSignature = make_signature!( - new fn(SIGNATURE_PREFERENCES), - (::SIGNATURE), - (::SIGNATURE), - (>::SIGNATURE), - ); - const NAME: [u8; SIG.unit.len] = { - let mut name: [u8; SIG.unit.len] = [0; SIG.unit.len]; - let mut i = 0; - while i < SIG.unit.len { - name[i] = SIG.unit.data[i]; - i += 1; - } - name - }; - similar_asserts::assert_eq!(&NAME, b"some_funk(uint8,uint32,uint32[])"); } #[test] --- a/crates/evm-coder/src/lib.rs +++ b/crates/evm-coder/src/lib.rs @@ -122,7 +122,7 @@ use primitive_types::{U256, H160, H256}; use core::str::from_utf8; - use crate::custom_signature::{SignatureUnit, SIGNATURE_SIZE_LIMIT}; + use crate::custom_signature::SignatureUnit; pub trait Signature { const SIGNATURE: SignatureUnit; @@ -133,14 +133,14 @@ } impl Signature for bool { - make_signature!(new fixed("bool")); + const SIGNATURE: SignatureUnit = make_signature!(new fixed("bool")); } macro_rules! define_simple_type { (type $ident:ident = $ty:ty) => { pub type $ident = $ty; impl Signature for $ty { - make_signature!(new fixed(stringify!($ident))); + const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($ident))); } }; } @@ -165,7 +165,7 @@ #[derive(Default, Debug)] pub struct bytes(pub Vec); impl Signature for bytes { - make_signature!(new fixed("bytes")); + const SIGNATURE: SignatureUnit = make_signature!(new fixed("bytes")); } /// Solidity doesn't have `void` type, however we have special implementation @@ -259,7 +259,7 @@ } impl Signature for EthCrossAccount { - make_signature!(new fixed("(address,uint256)")); + const SIGNATURE: SignatureUnit = make_signature!(new fixed("(address,uint256)")); } /// Convert `CrossAccountId` to `uint256`. --- a/crates/evm-coder/src/solidity.rs +++ b/crates/evm-coder/src/solidity.rs @@ -32,7 +32,7 @@ cmp::Reverse, }; use impl_trait_for_tuples::impl_for_tuples; -use crate::{types::*, custom_signature::FunctionSignature}; +use crate::{types::*, custom_signature::SignatureUnit}; #[derive(Default)] pub struct TypeCollector { @@ -486,7 +486,7 @@ pub docs: &'static [&'static str], pub selector: u32, pub hide: bool, - pub custom_signature: FunctionSignature, + pub custom_signature: SignatureUnit, pub name: &'static str, pub args: A, pub result: R, @@ -512,7 +512,7 @@ writeln!( writer, "\t{hide_comment}/// or in textual repr: {}", - self.custom_signature.as_str() + self.custom_signature.as_str().expect("bad utf-8") )?; write!(writer, "\t{hide_comment}function {}(", self.name)?; self.args.solidity_name(writer, tc)?; --- a/pallets/common/src/erc.rs +++ b/pallets/common/src/erc.rs @@ -21,8 +21,6 @@ types::*, execution::{Result, Error}, weight, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, }; pub use pallet_evm::{PrecompileOutput, PrecompileResult, PrecompileHandle, account::CrossAccountId}; use pallet_evm_coder_substrate::dispatch_to_evm; --- a/pallets/evm-contract-helpers/src/eth.rs +++ b/pallets/evm-contract-helpers/src/eth.rs @@ -19,13 +19,7 @@ extern crate alloc; use core::marker::PhantomData; use evm_coder::{ - abi::AbiWriter, - execution::Result, - generate_stubgen, solidity_interface, - types::*, - ToLog, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, + abi::AbiWriter, execution::Result, generate_stubgen, solidity_interface, types::*, ToLog, }; use pallet_evm::{ ExitRevert, OnCreate, OnMethodCall, PrecompileResult, PrecompileFailure, PrecompileHandle, --- a/pallets/fungible/src/erc.rs +++ b/pallets/fungible/src/erc.rs @@ -19,15 +19,7 @@ extern crate alloc; use core::char::{REPLACEMENT_CHARACTER, decode_utf16}; use core::convert::TryInto; -use evm_coder::{ - ToLog, - execution::*, - generate_stubgen, solidity_interface, - types::*, - weight, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, -}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight}; use up_data_structs::CollectionMode; use pallet_common::erc::{CommonEvmHandler, PrecompileResult}; use sp_std::vec::Vec; --- a/pallets/nonfungible/src/erc.rs +++ b/pallets/nonfungible/src/erc.rs @@ -24,15 +24,7 @@ char::{REPLACEMENT_CHARACTER, decode_utf16}, convert::TryInto, }; -use evm_coder::{ - ToLog, - execution::*, - generate_stubgen, solidity, solidity_interface, - types::*, - weight, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, -}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight}; use frame_support::BoundedVec; use up_data_structs::{ TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey, --- a/pallets/refungible/src/erc.rs +++ b/pallets/refungible/src/erc.rs @@ -25,15 +25,7 @@ char::{REPLACEMENT_CHARACTER, decode_utf16}, convert::TryInto, }; -use evm_coder::{ - ToLog, - execution::*, - generate_stubgen, solidity, solidity_interface, - types::*, - weight, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, -}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight}; use frame_support::{BoundedBTreeMap, BoundedVec}; use pallet_common::{ CollectionHandle, CollectionPropertyPermissions, --- a/pallets/refungible/src/erc_token.rs +++ b/pallets/refungible/src/erc_token.rs @@ -29,15 +29,7 @@ convert::TryInto, ops::Deref, }; -use evm_coder::{ - ToLog, - execution::*, - generate_stubgen, solidity_interface, - types::*, - weight, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, -}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity_interface, types::*, weight}; use pallet_common::{ CommonWeightInfo, erc::{CommonEvmHandler, PrecompileResult}, --- a/pallets/unique/src/eth/mod.rs +++ b/pallets/unique/src/eth/mod.rs @@ -18,13 +18,7 @@ use core::marker::PhantomData; use ethereum as _; -use evm_coder::{ - execution::*, - generate_stubgen, solidity, solidity_interface, - types::*, - custom_signature::{SignatureUnit, FunctionSignature, SignaturePreferences}, - make_signature, weight, -}; +use evm_coder::{execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight}; use frame_support::traits::Get; use crate::Pallet; -- gitstuff