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 sealed::CanBePlacedInVec for Property {}142143impl AbiType for Property {144 const SIGNATURE: SignatureUnit = make_signature!(new fixed("(string,bytes)"));145 const FIELDS_COUNT: usize = 2;146147 fn is_dynamic() -> bool {148 string::is_dynamic() || bytes::is_dynamic()149 }150151 fn size() -> usize {152 <string as AbiType>::size() + <bytes as AbiType>::size()153 }154}155156impl AbiRead for Property {157 fn abi_read(reader: &mut AbiReader) -> Result<Property> {158 let size = if !Property::is_dynamic() {159 Some(<Property as AbiType>::size())160 } else {161 None162 };163 let mut subresult = reader.subresult(size)?;164 let key = <string>::abi_read(&mut subresult)?;165 let value = <bytes>::abi_read(&mut subresult)?;166167 Ok(Property { key, value })168 }169}170171impl AbiWrite for Property {172 fn abi_write(&self, writer: &mut AbiWriter) {173 (&self.key, &self.value).abi_write(writer);174 }175}176177impl<T: AbiWrite + AbiType> AbiWrite for Vec<T> {178 fn abi_write(&self, writer: &mut AbiWriter) {179 let is_dynamic = T::is_dynamic();180 let mut sub = if is_dynamic {181 AbiWriter::new_dynamic(is_dynamic)182 } else {183 AbiWriter::new()184 };185186 187 (self.len() as u32).abi_write(&mut sub);188189 for item in self {190 item.abi_write(&mut sub);191 }192 writer.write_subresult(sub);193 }194}195196impl AbiWrite for () {197 fn abi_write(&self, _writer: &mut AbiWriter) {}198}199200201202203204impl<T: AbiWrite> AbiWrite for ResultWithPostInfo<T> {205 fn abi_write(&self, _writer: &mut AbiWriter) {206 debug_assert!(false, "shouldn't be called, see comment")207 }208 fn to_result(&self) -> ResultWithPostInfo<AbiWriter> {209 match self {210 Ok(v) => Ok(WithPostDispatchInfo {211 post_info: v.post_info.clone(),212 data: {213 let mut out = AbiWriter::new();214 v.data.abi_write(&mut out);215 out216 },217 }),218 Err(e) => Err(e.clone()),219 }220 }221}222223macro_rules! impl_tuples {224 ($($ident:ident)+) => {225 impl<$($ident: AbiType,)+> AbiType for ($($ident,)+)226 where227 $(228 $ident: AbiType,229 )+230 {231 const SIGNATURE: SignatureUnit = make_signature!(232 new fixed("(")233 $(nameof(<$ident>::SIGNATURE) fixed(","))+234 shift_left(1)235 fixed(")")236 );237 const FIELDS_COUNT: usize = 0 $(+ {let _ = <$ident as AbiType>::FIELDS_COUNT; 1})+;238239 fn is_dynamic() -> bool {240 false241 $(242 || <$ident>::is_dynamic()243 )*244 }245246 fn size() -> usize {247 0 $(+ <$ident>::size())+248 }249 }250251 impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}252253 impl<$($ident),+> AbiRead for ($($ident,)+)254 where255 Self: AbiType,256 $($ident: AbiRead + AbiType,)+257 {258 fn abi_read(reader: &mut AbiReader) -> Result<($($ident,)+)> {259 let is_dynamic = <Self>::is_dynamic();260 let size = if !is_dynamic { Some(<Self>::size()) } else { None };261 let mut subresult = reader.subresult(size)?;262 Ok((263 $({264 let value = <$ident>::abi_read(&mut subresult)?;265 if !is_dynamic {subresult.bytes_read(<$ident as AbiType>::size())};266 value267 },)+268 ))269 }270 }271272 #[allow(non_snake_case)]273 impl<$($ident),+> AbiWrite for ($($ident,)+)274 where275 $($ident: AbiWrite + AbiType,)+276 {277 fn abi_write(&self, writer: &mut AbiWriter) {278 let ($($ident,)+) = self;279 if <Self as AbiType>::is_dynamic() {280 let mut sub = AbiWriter::new();281 $($ident.abi_write(&mut sub);)+282 writer.write_subresult(sub);283 } else {284 $($ident.abi_write(writer);)+285 }286 }287 }288 };289}290291impl_tuples! {A}292impl_tuples! {A B}293impl_tuples! {A B C}294impl_tuples! {A B C D}295impl_tuples! {A B C D E}296impl_tuples! {A B C D E F}297impl_tuples! {A B C D E F G}298impl_tuples! {A B C D E F G H}299impl_tuples! {A B C D E F G H I}300impl_tuples! {A B C D E F G H I J}