1use crate::{2 custom_signature::SignatureUnit,3 execution::{Result, ResultWithPostInfo, WithPostDispatchInfo},4 make_signature, sealed,5 types::*,6};7use super::{traits::*, ABI_ALIGNMENT, AbiReader, AbiWriter};8use primitive_types::{U256, H160};910#[cfg(not(feature = "std"))]11use alloc::vec::Vec;1213macro_rules! impl_abi_type {14 ($ty:ty, $name:ident, $dynamic:literal) => {15 impl sealed::CanBePlacedInVec for $ty {}1617 impl AbiType for $ty {18 const SIGNATURE: SignatureUnit = make_signature!(new fixed(stringify!($name)));19 const FIELDS_COUNT: usize = 1;2021 fn is_dynamic() -> bool {22 $dynamic23 }2425 fn size() -> usize {26 ABI_ALIGNMENT27 }28 }29 };30}3132macro_rules! impl_abi_readable {33 ($ty:ty, $method:ident) => {34 impl AbiRead for $ty {35 fn abi_read(reader: &mut AbiReader) -> Result<$ty> {36 reader.$method()37 }38 }39 };40}4142macro_rules! impl_abi_writeable {43 ($ty:ty, $method:ident) => {44 impl AbiWrite for $ty {45 fn abi_write(&self, writer: &mut AbiWriter) {46 writer.$method(&self)47 }48 }49 };50}5152macro_rules! impl_abi {53 ($ty:ty, $method:ident, $dynamic:literal) => {54 impl_abi_type!($ty, $method, $dynamic);55 impl_abi_readable!($ty, $method);56 impl_abi_writeable!($ty, $method);57 };58}5960impl_abi!(bool, bool, false);61impl_abi!(u8, uint8, false);62impl_abi!(u32, uint32, false);63impl_abi!(u64, uint64, false);64impl_abi!(u128, uint128, false);65impl_abi!(U256, uint256, false);66impl_abi!(H160, address, false);67impl_abi!(string, string, true);6869impl_abi_writeable!(&str, string);7071impl_abi_type!(bytes, bytes, true);7273impl AbiRead for bytes {74 fn abi_read(reader: &mut AbiReader) -> Result<bytes> {75 Ok(bytes(reader.bytes()?))76 }77}7879impl AbiWrite for bytes {80 fn abi_write(&self, writer: &mut AbiWriter) {81 writer.bytes(self.0.as_slice())82 }83}8485impl_abi_type!(bytes4, bytes4, false);86impl AbiRead for bytes4 {87 fn abi_read(reader: &mut AbiReader) -> Result<bytes4> {88 reader.bytes4()89 }90}9192impl<T: AbiWrite> AbiWrite for &T {93 fn abi_write(&self, writer: &mut AbiWriter) {94 T::abi_write(self, writer);95 }96}9798impl<T: AbiType> AbiType for &T {99 const SIGNATURE: SignatureUnit = T::SIGNATURE;100 const FIELDS_COUNT: usize = T::FIELDS_COUNT;101102 fn is_dynamic() -> bool {103 T::is_dynamic()104 }105106 fn size() -> usize {107 T::size()108 }109}110111impl<T: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<T> {112 fn abi_read(reader: &mut AbiReader) -> Result<Vec<T>> {113 let mut sub = reader.subresult(None)?;114 let size = sub.uint32()? as usize;115 sub.subresult_offset = sub.offset;116 let is_dynamic = <T as AbiType>::is_dynamic();117 let mut out = Vec::with_capacity(size);118 for _ in 0..size {119 out.push(<T as AbiRead>::abi_read(&mut sub)?);120 if !is_dynamic {121 sub.bytes_read(<T as AbiType>::size());122 };123 }124 Ok(out)125 }126}127128impl<T: AbiType> AbiType for Vec<T> {129 const SIGNATURE: SignatureUnit = make_signature!(new nameof(T::SIGNATURE) fixed("[]"));130 const FIELDS_COUNT: usize = 1;131132 fn is_dynamic() -> bool {133 true134 }135136 fn size() -> usize {137 ABI_ALIGNMENT138 }139}140141impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {142 fn abi_write(&self, writer: &mut AbiWriter) {143 let is_dynamic = T::is_dynamic();144 let mut sub = if is_dynamic {145 AbiWriter::new_dynamic(is_dynamic)146 } else {147 AbiWriter::new()148 };149150 151 (self.len() as u32).abi_write(&mut sub);152153 for item in self {154 item.abi_write(&mut sub);155 }156 writer.write_subresult(sub);157 }158}159160impl AbiWrite for () {161 fn abi_write(&self, _writer: &mut AbiWriter) {}162}163164165166167168impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {169 fn abi_write(&self, _writer: &mut AbiWriter) {170 debug_assert!(false, "shouldn't be called, see comment")171 }172 fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {173 match self {174 Ok(v) => Ok(WithPostDispatchInfo {175 post_info: v.post_info.clone(),176 data: {177 let mut out = AbiWriter::new();178 v.data.abi_write(&mut out);179 out180 },181 }),182 Err(e) => Err(e.clone()),183 }184 }185}186187macro_rules! count {188 () => (0usize);189 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));190}191192macro_rules! impl_tuples {193 ($($ident:ident)+) => {194 impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)195 where196 $(197 $ident: AbiType,198 )+199 {200 const SIGNATURE: SignatureUnit = make_signature!(201 new fixed("(")202 $(nameof(<$ident>::SIGNATURE) fixed(","))+203 shift_left(1)204 fixed(")")205 );206 const FIELDS_COUNT: usize = count!($($ident)*);207208 fn is_dynamic() -> bool {209 false210 $(211 || <$ident>::is_dynamic()212 )*213 }214215 fn size() -> usize {216 0 $(+ <$ident>::size())+217 }218 }219220 impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}221222 impl<$($ident),+> AbiRead for ($($ident,)+)223 where224 Self: AbiType,225 $($ident: AbiRead + AbiType,)+226 {227 fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {228 let is_dynamic = <Self>::is_dynamic();229 let size = if !is_dynamic { Some(<Self>::size()) } else { None };230 let mut subresult = reader.subresult(size)?;231 Ok((232 $({233 let value = <$ident>::abi_read(&mut subresult)?;234 if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};235 value236 },)+237 ))238 }239 }240241 #[allow(non_snake_case)]242 impl<$($ident),+> AbiWrite for ($($ident,)+)243 where244 $($ident: AbiWrite + AbiType,)+245 {246 fn abi_write(&self, writer: &mut AbiWriter) {247 let ($($ident,)+) = self;248 if <Self as AbiType>::is_dynamic() {249 let mut sub = AbiWriter::new();250 $($ident.abi_write(&mut sub);)+251 writer.write_subresult(sub);252 } else {253 $($ident.abi_write(writer);)+254 }255 }256 }257 };258}259260impl_tuples! {A}261impl_tuples! {A B}262impl_tuples! {A B C}263impl_tuples! {A B C D}264impl_tuples! {A B C D E}265impl_tuples! {A B C D E F}266impl_tuples! {A B C D E F G}267impl_tuples! {A B C D E F G H}268impl_tuples! {A B C D E F G H I}269impl_tuples! {A B C D E F G H I J}