feat: add abi type trait (#519)
* feat: add abi type trait * rustfmt * fix: fix imports * feat: use const generic for u8 array * rustfmt * fix: imports
This commit is contained in:
parent
fb4d9a9ef1
commit
c5a45f7bf4
|
@ -17,6 +17,8 @@ pub use error::ParseError;
|
|||
mod human_readable;
|
||||
pub use human_readable::{parse as parse_abi, parse_str as parse_abi_str, AbiParser};
|
||||
|
||||
use crate::types::{H256, H512, U128, U64};
|
||||
|
||||
/// Extension trait for `ethabi::Function`.
|
||||
pub trait FunctionExt {
|
||||
/// Compute the method signature in the standard ABI format. This does not
|
||||
|
@ -65,6 +67,119 @@ impl EventExt for Event {
|
|||
}
|
||||
}
|
||||
|
||||
/// A trait for types that can be represented in the ethereum ABI.
|
||||
pub trait AbiType {
|
||||
/// The native ABI type this type represents.
|
||||
fn param_type() -> ParamType;
|
||||
}
|
||||
|
||||
impl AbiType for u8 {
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::Uint(8)
|
||||
}
|
||||
}
|
||||
|
||||
/// Additional trait for types that can appear in arrays
|
||||
///
|
||||
/// NOTE: this is necessary to handle the special case of `Vec<u8> => Bytes`
|
||||
pub trait AbiArrayType: AbiType {}
|
||||
|
||||
impl<T: AbiArrayType> AbiType for Vec<T> {
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::Array(Box::new(T::param_type()))
|
||||
}
|
||||
}
|
||||
impl<T: AbiArrayType> AbiArrayType for Vec<T> {}
|
||||
|
||||
impl<T: AbiArrayType, const N: usize> AbiType for [T; N] {
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::FixedArray(Box::new(T::param_type()), N)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> AbiType for [u8; N] {
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::FixedBytes(N)
|
||||
}
|
||||
}
|
||||
impl<const N: usize> AbiArrayType for [u8; N] {}
|
||||
|
||||
macro_rules! impl_abi_type {
|
||||
($($name:ty => $var:ident $(($value:expr))? ),*) => {
|
||||
$(
|
||||
impl AbiType for $name {
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::$var $( ($value) )?
|
||||
}
|
||||
}
|
||||
|
||||
impl AbiArrayType for $name {}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
impl_abi_type!(
|
||||
Vec<u8> => Bytes,
|
||||
Address => Address,
|
||||
bool => Bool,
|
||||
String => String,
|
||||
H256 => FixedBytes(32),
|
||||
H512 => FixedBytes(64),
|
||||
U64 => Uint(64),
|
||||
U128 => Uint(128),
|
||||
u16 => Uint(16),
|
||||
u32 => Uint(32),
|
||||
u64 => Uint(64),
|
||||
u128 => Uint(128),
|
||||
i8 => Int(8),
|
||||
i16 => Int(16),
|
||||
i32 => Int(32),
|
||||
i64 => Int(64),
|
||||
i128 => Int(128)
|
||||
);
|
||||
|
||||
macro_rules! impl_abi_type_tuple {
|
||||
($num: expr, $( $ty: ident),+) => {
|
||||
impl<$($ty, )+> AbiType for ($($ty,)+) where
|
||||
$(
|
||||
$ty: AbiType,
|
||||
)+
|
||||
{
|
||||
fn param_type() -> ParamType {
|
||||
ParamType::Tuple(
|
||||
::std::vec![
|
||||
$(
|
||||
$ty::param_type(),
|
||||
)+
|
||||
]
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl<$($ty, )+> AbiArrayType for ($($ty,)+) where
|
||||
$(
|
||||
$ty: AbiArrayType,
|
||||
)+ {}
|
||||
}
|
||||
}
|
||||
|
||||
impl_abi_type_tuple!(1, A);
|
||||
impl_abi_type_tuple!(2, A, B);
|
||||
impl_abi_type_tuple!(3, A, B, C);
|
||||
impl_abi_type_tuple!(4, A, B, C, D);
|
||||
impl_abi_type_tuple!(5, A, B, C, D, E);
|
||||
impl_abi_type_tuple!(6, A, B, C, D, E, F);
|
||||
impl_abi_type_tuple!(7, A, B, C, D, E, F, G);
|
||||
impl_abi_type_tuple!(8, A, B, C, D, E, F, G, H);
|
||||
impl_abi_type_tuple!(9, A, B, C, D, E, F, G, H, I);
|
||||
impl_abi_type_tuple!(10, A, B, C, D, E, F, G, H, I, J);
|
||||
impl_abi_type_tuple!(11, A, B, C, D, E, F, G, H, I, J, K);
|
||||
impl_abi_type_tuple!(12, A, B, C, D, E, F, G, H, I, J, K, L);
|
||||
impl_abi_type_tuple!(13, A, B, C, D, E, F, G, H, I, J, K, L, M);
|
||||
impl_abi_type_tuple!(14, A, B, C, D, E, F, G, H, I, J, K, L, M, N);
|
||||
impl_abi_type_tuple!(15, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
|
||||
impl_abi_type_tuple!(16, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
@ -117,4 +232,38 @@ mod tests {
|
|||
assert_eq!(signature, *expected);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn abi_type_works() {
|
||||
assert_eq!(ParamType::Bytes, Vec::<u8>::param_type());
|
||||
assert_eq!(
|
||||
ParamType::Array(Box::new(ParamType::Bytes)),
|
||||
Vec::<Vec<u8>>::param_type()
|
||||
);
|
||||
assert_eq!(
|
||||
ParamType::Array(Box::new(ParamType::Array(Box::new(ParamType::Bytes)))),
|
||||
Vec::<Vec<Vec<u8>>>::param_type()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
ParamType::Array(Box::new(ParamType::Uint(16))),
|
||||
Vec::<u16>::param_type()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
ParamType::Tuple(vec![ParamType::Bytes, ParamType::Address]),
|
||||
<(Vec<u8>, Address)>::param_type()
|
||||
);
|
||||
|
||||
assert_eq!(ParamType::FixedBytes(32), <[u8; 32]>::param_type());
|
||||
assert_eq!(
|
||||
ParamType::Array(Box::new(ParamType::FixedBytes(32))),
|
||||
Vec::<[u8; 32]>::param_type()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
ParamType::FixedArray(Box::new(ParamType::Uint(16)), 32),
|
||||
<[u16; 32]>::param_type()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -5,7 +5,7 @@ pub type Selector = [u8; 4];
|
|||
/// A transaction Hash
|
||||
pub use ethabi::ethereum_types::H256 as TxHash;
|
||||
|
||||
pub use ethabi::ethereum_types::{Address, Bloom, H160, H256, U128, U256, U64};
|
||||
pub use ethabi::ethereum_types::{Address, Bloom, H160, H256, H512, U128, U256, U64};
|
||||
|
||||
pub mod transaction;
|
||||
pub use transaction::{
|
||||
|
|
Loading…
Reference in New Issue