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! impl_tuples {188 ($($ident:ident)+) => {189 impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)190 where191 $(192 $ident: AbiType,193 )+194 {195 const SIGNATURE: SignatureUnit = make_signature!(196 new fixed("(")197 $(nameof(<$ident>::SIGNATURE) fixed(","))+198 shift_left(1)199 fixed(")")200 );201 const FIELDS_COUNT: usize = 0 $(+ {let _ = <$ident as AbiType>::FIELDS_COUNT; 1})+;202203 fn is_dynamic() -> bool {204 false205 $(206 || <$ident>::is_dynamic()207 )*208 }209210 fn size() -> usize {211 0 $(+ <$ident>::size())+212 }213 }214215 impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}216217 impl<$($ident),+> AbiRead for ($($ident,)+)218 where219 Self: AbiType,220 $($ident: AbiRead + AbiType,)+221 {222 fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {223 let is_dynamic = <Self>::is_dynamic();224 let size = if !is_dynamic { Some(<Self>::size()) } else { None };225 let mut subresult = reader.subresult(size)?;226 Ok((227 $({228 let value = <$ident>::abi_read(&mut subresult)?;229 if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};230 value231 },)+232 ))233 }234 }235236 #[allow(non_snake_case)]237 impl<$($ident),+> AbiWrite for ($($ident,)+)238 where239 $($ident: AbiWrite + AbiType,)+240 {241 fn abi_write(&self, writer: &mut AbiWriter) {242 let ($($ident,)+) = self;243 if <Self as AbiType>::is_dynamic() {244 let mut sub = AbiWriter::new();245 $($ident.abi_write(&mut sub);)+246 writer.write_subresult(sub);247 } else {248 $($ident.abi_write(writer);)+249 }250 }251 }252 };253}254255impl_tuples! {A}256impl_tuples! {A B}257impl_tuples! {A B C}258impl_tuples! {A B C D}259impl_tuples! {A B C D E}260impl_tuples! {A B C D E F}261impl_tuples! {A B C D E F G}262impl_tuples! {A B C D E F G H}263impl_tuples! {A B C D E F G H I}264impl_tuples! {A B C D E F G H I J}