difftreelog
refactor unify function and type signature handling
in: master
12 files changed
crates/evm-coder/procedural/src/solidity_interface.rsdiffbeforeafterboth--- 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! { (<Vec<#vec_token>>::SIGNATURE) }
- } else {
- quote! { <Vec<#vec_token>> }
- };
- 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::<usize>()?;
- // 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! { (<Vec<#vec_token>>::SIGNATURE) }
- // } else {
- // quote! { <Vec<#vec_token>> }
- // };
- // 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! {
crates/evm-coder/src/abi.rsdiffbeforeafterboth--- 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<R: Signature> Signature for Vec<R> {
- 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
"
crates/evm-coder/src/custom_signature.rsdiffbeforeafterboth73//! }73//! }74//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {74//! impl<T: SoliditySignature> SoliditySignature for Vec<T> {75//! make_signature!(new nameof(T) fixed("[]"));75//! make_signature!(new nameof(T) fixed("[]"));76//! }77//!78//! // Function signature settings79//! const SIGNATURE_PREFERENCES: SignaturePreferences = SignaturePreferences {80//! open_name: Some(SignatureUnit::new("some_funk")),81//! open_delimiter: Some(SignatureUnit::new("(")),82//! param_delimiter: Some(SignatureUnit::new(",")),83//! close_delimiter: Some(SignatureUnit::new(")")),84//! close_name: None,85//! };86//!87//! // Create functions signatures88//! fn make_func_without_args() {89//! const SIG: FunctionSignature = make_signature!(90//! new fn(SIGNATURE_PREFERENCES),91//! );92//! let name = SIG.as_str();93//! similar_asserts::assert_eq!(name, "some_funk()");94//! }95//!96//! fn make_func_with_3_args() {97//! const SIG: FunctionSignature = make_signature!(98//! new fn(SIGNATURE_PREFERENCES),99//! (<u8>::SIGNATURE),100//! (<u8>::SIGNATURE),101//! (<Vec<u8>>::SIGNATURE),102//! );103//! let name = SIG.as_str();104//! similar_asserts::assert_eq!(name, "some_funk(uint8,uint8,uint8[])");105//! }76//! }106//! ```77//! ```107use core::str::from_utf8;10878109/// The maximum length of the signature.79/// The maximum length of the signature.110pub const SIGNATURE_SIZE_LIMIT: usize = 256;80pub const SIGNATURE_SIZE_LIMIT: usize = 256;111112/// Function signature formatting preferences.113#[derive(Debug)]114pub struct SignaturePreferences {115 /// The name of the function before the list of parameters: `*some*(param1,param2)func`116 pub open_name: Option<SignatureUnit>,117 /// Opening separator: `some*(*param1,param2)func`118 pub open_delimiter: Option<SignatureUnit>,119 /// Parameters separator: `some(param1*,*param2)func`120 pub param_delimiter: Option<SignatureUnit>,121 /// Closinging separator: `some(param1,param2*)*func`122 pub close_delimiter: Option<SignatureUnit>,123 /// The name of the function after the list of parameters: `some(param1,param2)*func*`124 pub close_name: Option<SignatureUnit>,125}126127/// Constructs and stores the signature of the function.128#[derive(Debug)]129pub struct FunctionSignature {130 /// Storage for function signature.131 pub unit: SignatureUnit,132 preferences: SignaturePreferences,133}134135impl FunctionSignature {136 /// Start constructing the signature. It is written to the storage137 /// [`SignaturePreferences::open_name`] and [`SignaturePreferences::open_delimiter`].138 pub const fn new(preferences: SignaturePreferences) -> FunctionSignature {139 let mut dst = [0_u8; SIGNATURE_SIZE_LIMIT];140 let mut dst_offset = 0;141 if let Some(ref name) = preferences.open_name {142 crate::make_signature!(@copy(name.data, dst, name.len, dst_offset));143 }144 if let Some(ref delimiter) = preferences.open_delimiter {145 crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset));146 }147 FunctionSignature {148 unit: SignatureUnit {149 data: dst,150 len: dst_offset,151 },152 preferences,153 }154 }155156 /// Add a function parameter to the signature. It is written to the storage157 /// `param` [`SignatureUnit`] and [`SignaturePreferences::param_delimiter`].158 pub const fn add_param(159 signature: FunctionSignature,160 param: SignatureUnit,161 ) -> FunctionSignature {162 let mut dst = signature.unit.data;163 let mut dst_offset = signature.unit.len;164 crate::make_signature!(@copy(param.data, dst, param.len, dst_offset));165 if let Some(ref delimiter) = signature.preferences.param_delimiter {166 crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset));167 }168 FunctionSignature {169 unit: SignatureUnit {170 data: dst,171 len: dst_offset,172 },173 ..signature174 }175 }176177 /// Complete signature construction. It is written to the storage178 /// [`SignaturePreferences::close_delimiter`] and [`SignaturePreferences::close_name`].179 pub const fn done(signature: FunctionSignature, owerride: bool) -> FunctionSignature {180 let mut dst = signature.unit.data;181 let mut dst_offset = signature.unit.len - if owerride { 1 } else { 0 };182 if let Some(ref delimiter) = signature.preferences.close_delimiter {183 crate::make_signature!(@copy(delimiter.data, dst, delimiter.len, dst_offset));184 }185 if let Some(ref name) = signature.preferences.close_name {186 crate::make_signature!(@copy(name.data, dst, name.len, dst_offset));187 }188 FunctionSignature {189 unit: SignatureUnit {190 data: dst,191 len: dst_offset,192 },193 ..signature194 }195 }196197 /// Represent the signature as `&str'.198 pub fn as_str(&self) -> &str {199 from_utf8(&self.unit.data[..self.unit.len]).expect("bad utf-8")200 }201}20281203/// Storage for the signature or its elements.82/// Storage for the signature or its elements.204#[derive(Debug)]83#[derive(Debug)]222 len: name_len,101 len: name_len,223 }102 }224 }103 }104 /// String conversion105 pub fn as_str(&self) -> Option<&str> {106 core::str::from_utf8(&self.data[0..self.len]).ok()107 }225}108}226109227/// ### Macro to create signatures of types and functions.110/// ### Macro to create signatures of types and functions.230/// ```ignore113/// ```ignore231/// make_signature!(new fixed("uint8")); // Simple type114/// make_signature!(new fixed("uint8")); // Simple type232/// make_signature!(new fixed("(") nameof(u8) fixed(",") nameof(u8) fixed(")")); // Composite type115/// make_signature!(new fixed("(") nameof(u8) fixed(",") nameof(u8) fixed(")")); // Composite type233/// ```234/// Format for creating a function of the function:235/// ```ignore236/// const SIG: FunctionSignature = make_signature!(237/// new fn(SIGNATURE_PREFERENCES),238/// (u8::SIGNATURE),239/// (<(u8,u8)>::SIGNATURE),240/// );241/// ```116/// ```242#[macro_export]117#[macro_export]243macro_rules! make_signature {118macro_rules! make_signature {244 (new fn($func:expr)$(,)*) => {245 {246 let fs = FunctionSignature::new($func);247 let fs = FunctionSignature::done(fs, false);248 fs249 }250 };251 (new fn($func:expr), $($tt:tt,)*) => {252 {253 let fs = FunctionSignature::new($func);254 let fs = make_signature!(@param; fs, $($tt),*);255 fs256 }257 };258259 (@param; $func:expr) => {260 FunctionSignature::done($func, true)261 };262 (@param; $func:expr, $param:expr) => {263 make_signature!(@param; FunctionSignature::add_param($func, $param))264 };265 (@param; $func:expr, $param:expr, $($tt:tt),*) => {266 make_signature!(@param; FunctionSignature::add_param($func, $param), $($tt),*)267 };268269 (new $($tt:tt)*) => {119 (new $($tt:tt)*) => {270 const SIGNATURE: SignatureUnit = SignatureUnit {120 ($crate::custom_signature::SignatureUnit {271 data: {121 data: {272 let mut out = [0u8; SIGNATURE_SIZE_LIMIT];122 let mut out = [0u8; $crate::custom_signature::SIGNATURE_SIZE_LIMIT];273 let mut dst_offset = 0;123 let mut dst_offset = 0;274 make_signature!(@data(out, dst_offset); $($tt)*);124 $crate::make_signature!(@data(out, dst_offset); $($tt)*);275 out125 out276 },126 },277 len: {0 + make_signature!(@size; $($tt)*)},127 len: {0 + $crate::make_signature!(@size; $($tt)*)},278 };128 })279 };129 };280130281 (@size;) => {131 (@size;) => {282 0132 0283 };133 };284 (@size; fixed($expr:expr) $($tt:tt)*) => {134 (@size; fixed($expr:expr) $($tt:tt)*) => {285 $expr.len() + make_signature!(@size; $($tt)*)135 $expr.len() + $crate::make_signature!(@size; $($tt)*)286 };136 };287 (@size; nameof($expr:ty) $($tt:tt)*) => {137 (@size; nameof($expr:ty) $($tt:tt)*) => {288 <$expr>::SIGNATURE.len + make_signature!(@size; $($tt)*)138 <$expr>::SIGNATURE.len + $crate::make_signature!(@size; $($tt)*)289 };139 };290 (@size; shift_left($expr:expr) $($tt:tt)*) => {140 (@size; shift_left($expr:expr) $($tt:tt)*) => {291 make_signature!(@size; $($tt)*) - $expr141 $crate::make_signature!(@size; $($tt)*) - $expr292 };142 };293143294 (@data($dst:ident, $dst_offset:ident);) => {};144 (@data($dst:ident, $dst_offset:ident);) => {};295 (@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => {145 (@data($dst:ident, $dst_offset:ident); fixed($expr:expr) $($tt:tt)*) => {296 {146 {297 let data = $expr.as_bytes();147 let data = $expr.as_bytes();298 let data_len = data.len();148 let data_len = data.len();299 make_signature!(@copy(data, $dst, data_len, $dst_offset));149 $crate::make_signature!(@copy(data, $dst, data_len, $dst_offset));300 }150 }301 make_signature!(@data($dst, $dst_offset); $($tt)*)151 $crate::make_signature!(@data($dst, $dst_offset); $($tt)*)302 };152 };303 (@data($dst:ident, $dst_offset:ident); nameof($expr:ty) $($tt:tt)*) => {153 (@data($dst:ident, $dst_offset:ident); nameof($expr:ty) $($tt:tt)*) => {304 {154 {305 make_signature!(@copy(&<$expr>::SIGNATURE.data, $dst, <$expr>::SIGNATURE.len, $dst_offset));155 $crate::make_signature!(@copy(&<$expr>::SIGNATURE.data, $dst, <$expr>::SIGNATURE.len, $dst_offset));306 }156 }307 make_signature!(@data($dst, $dst_offset); $($tt)*)157 $crate::make_signature!(@data($dst, $dst_offset); $($tt)*)308 };158 };309 (@data($dst:ident, $dst_offset:ident); shift_left($expr:expr) $($tt:tt)*) => {159 (@data($dst:ident, $dst_offset:ident); shift_left($expr:expr) $($tt:tt)*) => {310 $dst_offset -= $expr;160 $dst_offset -= $expr;311 make_signature!(@data($dst, $dst_offset); $($tt)*)161 $crate::make_signature!(@data($dst, $dst_offset); $($tt)*)312 };162 };313163314 (@copy($src:expr, $dst:expr, $src_len:expr, $dst_offset:ident)) => {164 (@copy($src:expr, $dst:expr, $src_len:expr, $dst_offset:ident)) => {328mod test {178mod test {329 use core::str::from_utf8;179 use core::str::from_utf8;330180331 use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit, FunctionSignature, SignaturePreferences};181 use super::{SIGNATURE_SIZE_LIMIT, SignatureUnit};332182333 trait Name {183 trait Name {334 const SIGNATURE: SignatureUnit;184 const SIGNATURE: SignatureUnit;339 }189 }340190341 impl Name for u8 {191 impl Name for u8 {342 make_signature!(new fixed("uint8"));192 const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint8"));343 }193 }344 impl Name for u32 {194 impl Name for u32 {345 make_signature!(new fixed("uint32"));195 const SIGNATURE: SignatureUnit = make_signature!(new fixed("uint32"));346 }196 }347 impl<T: Name> Name for Vec<T> {197 impl<T: Name> Name for Vec<T> {348 make_signature!(new nameof(T) fixed("[]"));198 const SIGNATURE: SignatureUnit = make_signature!(new nameof(T) fixed("[]"));349 }199 }350 impl<A: Name, B: Name> Name for (A, B) {200 impl<A: Name, B: Name> Name for (A, B) {201 const SIGNATURE: SignatureUnit =351 make_signature!(new fixed("(") nameof(A) fixed(",") nameof(B) fixed(")"));202 make_signature!(new fixed("(") nameof(A) fixed(",") nameof(B) fixed(")"));352 }203 }353 impl<A: Name> Name for (A,) {204 impl<A: Name> Name for (A,) {205 const SIGNATURE: SignatureUnit =354 make_signature!(new fixed("(") nameof(A) fixed(",") shift_left(1) fixed(")"));206 make_signature!(new fixed("(") nameof(A) fixed(",") shift_left(1) fixed(")"));355 }207 }356208362 };214 };363 }215 }364365 const SIGNATURE_PREFERENCES: SignaturePreferences = SignaturePreferences {366 open_name: Some(SignatureUnit::new("some_funk")),367 open_delimiter: Some(SignatureUnit::new("(")),368 param_delimiter: Some(SignatureUnit::new(",")),369 close_delimiter: Some(SignatureUnit::new(")")),370 close_name: None,371 };372216373 #[test]217 #[test]374 fn simple() {218 fn simple() {423 assert_eq!(<MaxSize>::name(), "!".repeat(SIGNATURE_SIZE_LIMIT));267 assert_eq!(<MaxSize>::name(), "!".repeat(SIGNATURE_SIZE_LIMIT));424 }268 }425426 #[test]427 fn make_func_without_args() {428 const SIG: FunctionSignature = make_signature!(429 new fn(SIGNATURE_PREFERENCES)430 );431 let name = SIG.as_str();432 similar_asserts::assert_eq!(name, "some_funk()");433 }434435 #[test]436 fn make_func_with_1_args() {437 const SIG: FunctionSignature = make_signature!(438 new fn(SIGNATURE_PREFERENCES),439 (<u8>::SIGNATURE),440 );441 let name = SIG.as_str();442 similar_asserts::assert_eq!(name, "some_funk(uint8)");443 }444445 #[test]446 fn make_func_with_2_args() {447 const SIG: FunctionSignature = make_signature!(448 new fn(SIGNATURE_PREFERENCES),449 (u8::SIGNATURE),450 (<Vec<u32>>::SIGNATURE),451 );452 let name = SIG.as_str();453 similar_asserts::assert_eq!(name, "some_funk(uint8,uint32[])");454 }455456 #[test]457 fn make_func_with_3_args() {458 const SIG: FunctionSignature = make_signature!(459 new fn(SIGNATURE_PREFERENCES),460 (<u8>::SIGNATURE),461 (<u32>::SIGNATURE),462 (<Vec<u32>>::SIGNATURE),463 );464 let name = SIG.as_str();465 similar_asserts::assert_eq!(name, "some_funk(uint8,uint32,uint32[])");466 }467468 #[test]469 fn make_slice_from_signature() {470 const SIG: FunctionSignature = make_signature!(471 new fn(SIGNATURE_PREFERENCES),472 (<u8>::SIGNATURE),473 (<u32>::SIGNATURE),474 (<Vec<u32>>::SIGNATURE),475 );476 const NAME: [u8; SIG.unit.len] = {477 let mut name: [u8; SIG.unit.len] = [0; SIG.unit.len];478 let mut i = 0;479 while i < SIG.unit.len {480 name[i] = SIG.unit.data[i];481 i += 1;482 }483 name484 };485 similar_asserts::assert_eq!(&NAME, b"some_funk(uint8,uint32,uint32[])");486 }487269488 #[test]270 #[test]489 fn shift() {271 fn shift() {crates/evm-coder/src/lib.rsdiffbeforeafterboth--- 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<u8>);
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`.
crates/evm-coder/src/solidity.rsdiffbeforeafterboth--- 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)?;
pallets/common/src/erc.rsdiffbeforeafterboth--- 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;
pallets/evm-contract-helpers/src/eth.rsdiffbeforeafterboth--- 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,
pallets/fungible/src/erc.rsdiffbeforeafterboth--- 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;
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- 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,
pallets/refungible/src/erc.rsdiffbeforeafterboth--- 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,
pallets/refungible/src/erc_token.rsdiffbeforeafterboth--- 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},
pallets/unique/src/eth/mod.rsdiffbeforeafterboth--- 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;